dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 482
 483 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 484
 485
 486 // add here SWIG version check
 487
 488 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 489 // disable Swig-dependent warnings
 490
 491 // 'identifier1' has C-linkage specified,
 492 // but returns UDT 'identifier2' which is incompatible with C
 493 #pragma warning(disable: 4190)
 494
 495 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 496 #pragma warning(disable: 4800)
 497
 498 // debug info too long etc etc
 499 #pragma warning(disable: 4786)
 500 #endif
 501
 502
 503 #include <stdexcept>
 504
 505
 506 #include <string>
 507
 508
 509 #include <vector>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <map>
 515 #include <algorithm>
 516 #include <stdexcept>
 517
 518
 519 #include <utility>
 520
 521
 522 typedef float floatp;
 523
 524 SWIGINTERN floatp *new_floatp(){
 525   return new float();
 526 }
 527 SWIGINTERN void delete_floatp(floatp *self){
 528   if (self) delete self;
 529 }
 530 SWIGINTERN void floatp_assign(floatp *self,float value){
 531   *self = value;
 532 }
 533 SWIGINTERN float floatp_value(floatp *self){
 534   return *self;
 535 }
 536 SWIGINTERN float *floatp_cast(floatp *self){
 537   return self;
 538 }
 539 SWIGINTERN floatp *floatp_frompointer(float *t){
 540   return (floatp *) t;
 541 }
 542
 543 typedef int intp;
 544
 545 SWIGINTERN intp *new_intp(){
 546   return new int();
 547 }
 548 SWIGINTERN void delete_intp(intp *self){
 549   if (self) delete self;
 550 }
 551 SWIGINTERN void intp_assign(intp *self,int value){
 552   *self = value;
 553 }
 554 SWIGINTERN int intp_value(intp *self){
 555   return *self;
 556 }
 557 SWIGINTERN int *intp_cast(intp *self){
 558   return self;
 559 }
 560 SWIGINTERN intp *intp_frompointer(int *t){
 561   return (intp *) t;
 562 }
 563
 564 typedef double doublep;
 565
 566 SWIGINTERN doublep *new_doublep(){
 567   return new double();
 568 }
 569 SWIGINTERN void delete_doublep(doublep *self){
 570   if (self) delete self;
 571 }
 572 SWIGINTERN void doublep_assign(doublep *self,double value){
 573   *self = value;
 574 }
 575 SWIGINTERN double doublep_value(doublep *self){
 576   return *self;
 577 }
 578 SWIGINTERN double *doublep_cast(doublep *self){
 579   return self;
 580 }
 581 SWIGINTERN doublep *doublep_frompointer(double *t){
 582   return (doublep *) t;
 583 }
 584
 585 typedef unsigned int uintp;
 586
 587 SWIGINTERN uintp *new_uintp(){
 588   return new unsigned int();
 589 }
 590 SWIGINTERN void delete_uintp(uintp *self){
 591   if (self) delete self;
 592 }
 593 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 594   *self = value;
 595 }
 596 SWIGINTERN unsigned int uintp_value(uintp *self){
 597   return *self;
 598 }
 599 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 600   return self;
 601 }
 602 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 603   return (uintp *) t;
 604 }
 605
 606 typedef unsigned short ushortp;
 607
 608 SWIGINTERN ushortp *new_ushortp(){
 609   return new unsigned short();
 610 }
 611 SWIGINTERN void delete_ushortp(ushortp *self){
 612   if (self) delete self;
 613 }
 614 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 615   *self = value;
 616 }
 617 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 618   return *self;
 619 }
 620 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 621   return self;
 622 }
 623 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 624   return (ushortp *) t;
 625 }
 626
 627 unsigned int int_to_uint(int x) {
 628    return (unsigned int) x;
 629 }
 630
 631
 632 using namespace Dali;
 633 using namespace Dali::Toolkit;
 634
 635 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 636 {
 637   bool result = false;
 638   try
 639   {
 640     // C++ code. DALi uses Handle <-> Body design pattern.
 641     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 642     // Handles in DALi can be converted into a boolean type
 643     // to check if the handle has a valid body attached to it.
 644     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 645     if( *self )
 646     {
 647       result = true;
 648     }
 649     else
 650     {
 651       result = false;
 652     }
 653   }
 654   catch (std::out_of_range& e)
 655   {
 656     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (std::exception& e)
 660   {
 661     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 662     return 0;
 663   }
 664   catch (DaliException e)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 667     return 0;
 668   }
 669   catch (...)
 670   {
 671     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 672     return 0;
 673   }
 674   return result;
 675 }
 676
 677 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 678 {
 679   bool result = false;
 680   try
 681   {
 682     // C++ code. Check if two handles reference the same implemtion
 683     if( *self == rhs)
 684     {
 685       result = true;
 686     }
 687     else
 688     {
 689       result = false;
 690     }
 691   }
 692   catch (std::out_of_range& e)
 693   {
 694     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (std::exception& e)
 698   {
 699     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 700     return 0;
 701   }
 702   catch (DaliException e)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 705     return 0;
 706   }
 707   catch (...)
 708   {
 709     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 710     return 0;
 711   }
 712   return result;
 713 }
 714
 715
 716 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 717      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 718    }
 719 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 720      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 721    }
 722 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 723         std::vector< Dali::TouchPoint >* pv = 0;
 724         if (capacity >= 0) {
 725           pv = new std::vector< Dali::TouchPoint >();
 726           pv->reserve(capacity);
 727        } else {
 728           throw std::out_of_range("capacity");
 729        }
 730        return pv;
 731       }
 732 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 733         if (index>=0 && index<(int)self->size())
 734           return (*self)[index];
 735         else
 736           throw std::out_of_range("index");
 737       }
 738 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 739         if (index>=0 && index<(int)self->size())
 740           return (*self)[index];
 741         else
 742           throw std::out_of_range("index");
 743       }
 744 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 745         if (index>=0 && index<(int)self->size())
 746           (*self)[index] = val;
 747         else
 748           throw std::out_of_range("index");
 749       }
 750 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 751         self->insert(self->end(), values.begin(), values.end());
 752       }
 753 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 754         if (index < 0)
 755           throw std::out_of_range("index");
 756         if (count < 0)
 757           throw std::out_of_range("count");
 758         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 759           throw std::invalid_argument("invalid range");
 760         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 761       }
 762 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 763         if (index>=0 && index<(int)self->size()+1)
 764           self->insert(self->begin()+index, x);
 765         else
 766           throw std::out_of_range("index");
 767       }
 768 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 769         if (index>=0 && index<(int)self->size()+1)
 770           self->insert(self->begin()+index, values.begin(), values.end());
 771         else
 772           throw std::out_of_range("index");
 773       }
 774 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 775         if (index>=0 && index<(int)self->size())
 776           self->erase(self->begin() + index);
 777         else
 778           throw std::out_of_range("index");
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 781         if (index < 0)
 782           throw std::out_of_range("index");
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 786           throw std::invalid_argument("invalid range");
 787         self->erase(self->begin()+index, self->begin()+index+count);
 788       }
 789 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 790         if (count < 0)
 791           throw std::out_of_range("count");
 792         return new std::vector< Dali::TouchPoint >(count, value);
 793       }
 794 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 795         std::reverse(self->begin(), self->end());
 796       }
 797 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 798         if (index < 0)
 799           throw std::out_of_range("index");
 800         if (count < 0)
 801           throw std::out_of_range("count");
 802         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 803           throw std::invalid_argument("invalid range");
 804         std::reverse(self->begin()+index, self->begin()+index+count);
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 807         if (index < 0)
 808           throw std::out_of_range("index");
 809         if (index+values.size() > self->size())
 810           throw std::out_of_range("index");
 811         std::copy(values.begin(), values.end(), self->begin()+index);
 812       }
 813 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 814          return self->Empty();
 815       }
 816 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 817         return self->GetConnectionCount();
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 820           self->Connect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 823           self->Disconnect( func );
 824       }
 825 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 826           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 827 /*@SWIG@*/ self->Emit( arg );
 828       }
 829 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 830          return self->Empty();
 831       }
 832 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 833         return self->GetConnectionCount();
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 836           self->Connect( func );
 837       }
 838 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 839           self->Disconnect( func );
 840       }
 841 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 842           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 843 /*@SWIG@*/ self->Emit( arg );
 844       }
 845 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 846          return self->Empty();
 847       }
 848 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 849         return self->GetConnectionCount();
 850       }
 851 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 852           self->Connect( func );
 853       }
 854 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 855           self->Disconnect( func );
 856       }
 857 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 858           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 859 /*@SWIG@*/ self->Emit( arg );
 860       }
 861 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 862          return self->Empty();
 863       }
 864 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 865         return self->GetConnectionCount();
 866       }
 867 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 868           self->Connect( func );
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 871           self->Disconnect( func );
 872       }
 873 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 874           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 875 /*@SWIG@*/ self->Emit( arg );
 876       }
 877 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 878          return self->Empty();
 879       }
 880 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 881         return self->GetConnectionCount();
 882       }
 883 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 884           self->Connect( func );
 885       }
 886 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 887           self->Disconnect( func );
 888       }
 889 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 890           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 891 /*@SWIG@*/ self->Emit( arg );
 892       }
 893 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 894          return self->Empty();
 895       }
 896 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 897         return self->GetConnectionCount();
 898       }
 899 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 900         self->Connect( func );
 901       }
 902 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 903         self->Disconnect( func );
 904       }
 905 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 906         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 907 /*@SWIG@*/ self->Emit( arg1, arg2 );
 908       }
 909 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 910          return self->Empty();
 911       }
 912 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 913         return self->GetConnectionCount();
 914       }
 915 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 916         self->Connect( func );
 917       }
 918 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 919         self->Disconnect( func );
 920       }
 921 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 922         return self->Emit( arg1, arg2 );
 923       }
 924 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 925          return self->Empty();
 926       }
 927 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 928         return self->GetConnectionCount();
 929       }
 930 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 931         self->Connect( func );
 932       }
 933 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 934         self->Disconnect( func );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 937         return self->Emit( arg1, arg2 );
 938       }
 939 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 940          return self->Empty();
 941       }
 942 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 943         return self->GetConnectionCount();
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 946         self->Connect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 949         self->Disconnect( func );
 950       }
 951 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 952         return self->Emit( arg1, arg2 );
 953       }
 954 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 955          return self->Empty();
 956       }
 957 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 958         return self->GetConnectionCount();
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 961           self->Connect( func );
 962       }
 963 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 964           self->Disconnect( func );
 965       }
 966 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 967           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 968 /*@SWIG@*/ self->Emit( arg );
 969       }
 970 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 971          return self->Empty();
 972       }
 973 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 974         return self->GetConnectionCount();
 975       }
 976 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 977           self->Connect( func );
 978       }
 979 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 980           self->Disconnect( func );
 981       }
 982 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 983           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 984 /*@SWIG@*/ self->Emit( arg );
 985       }
 986 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 987          return self->Empty();
 988       }
 989 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 990         return self->GetConnectionCount();
 991       }
 992 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 993           self->Connect( func );
 994       }
 995 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 996           self->Disconnect( func );
 997       }
 998 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 999           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1000 /*@SWIG@*/ self->Emit( arg );
1001       }
1002 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1003          return self->Empty();
1004       }
1005 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1006         return self->GetConnectionCount();
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1009           self->Connect( func );
1010       }
1011 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
1012           self->Disconnect( func );
1013       }
1014 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
1015           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1016 /*@SWIG@*/ self->Emit( arg );
1017       }
1018 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1019          return self->Empty();
1020       }
1021 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
1022         return self->GetConnectionCount();
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1025         self->Connect( func );
1026       }
1027 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
1028         self->Disconnect( func );
1029       }
1030 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
1031         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1032 /*@SWIG@*/ self->Emit( arg1, arg2 );
1033       }
1034 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1035          return self->Empty();
1036       }
1037 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
1038         return self->GetConnectionCount();
1039       }
1040 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1041         self->Connect( func );
1042       }
1043 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
1044         self->Disconnect( func );
1045       }
1046 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
1047         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1048 /*@SWIG@*/ self->Emit( arg1, arg2 );
1049       }
1050 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1051          return self->Empty();
1052       }
1053 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1054         return self->GetConnectionCount();
1055       }
1056 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1057         self->Connect( func );
1058       }
1059 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
1060         self->Disconnect( func );
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
1063         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1064 /*@SWIG@*/ self->Emit( arg1, arg2 );
1065       }
1066 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1067          return self->Empty();
1068       }
1069 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1070         return self->GetConnectionCount();
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1073           self->Connect( func );
1074       }
1075 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1076           self->Disconnect( func );
1077       }
1078 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1079           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1080 /*@SWIG@*/ self->Emit( arg );
1081       }
1082 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1083          return self->Empty();
1084       }
1085 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1086         return self->GetConnectionCount();
1087       }
1088 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1089           return self->Connect( func );
1090       }
1091 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1092           self->Disconnect( func );
1093       }
1094 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1095           self->Emit( arg1, arg3 );
1096       }
1097 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1098          return self->Empty();
1099       }
1100 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > const *self){
1101         return self->GetConnectionCount();
1102       }
1103 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1104           return self->Connect( func );
1105       }
1106 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,void (*func)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)){
1107           self->Disconnect( func );
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *self,Dali::Actor arg1,bool arg2,Dali::DevelActor::VisibilityChange::Type arg3){
1110           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1111 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1112       }
1113
1114 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1115          return self->Empty();
1116       }
1117 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1118         return self->GetConnectionCount();
1119       }
1120 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1121           self->Connect( func );
1122       }
1123 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1124           self->Disconnect( func );
1125       }
1126 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1127           return self->Emit();
1128       }
1129
1130 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1131         std::vector< unsigned int >* pv = 0;
1132         if (capacity >= 0) {
1133           pv = new std::vector< unsigned int >();
1134           pv->reserve(capacity);
1135        } else {
1136           throw std::out_of_range("capacity");
1137        }
1138        return pv;
1139       }
1140 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1141         if (index>=0 && index<(int)self->size())
1142           return (*self)[index];
1143         else
1144           throw std::out_of_range("index");
1145       }
1146 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1147         if (index>=0 && index<(int)self->size())
1148           return (*self)[index];
1149         else
1150           throw std::out_of_range("index");
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1153         if (index>=0 && index<(int)self->size())
1154           (*self)[index] = val;
1155         else
1156           throw std::out_of_range("index");
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1159         self->insert(self->end(), values.begin(), values.end());
1160       }
1161 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1162         if (index < 0)
1163           throw std::out_of_range("index");
1164         if (count < 0)
1165           throw std::out_of_range("count");
1166         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1167           throw std::invalid_argument("invalid range");
1168         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1171         if (index>=0 && index<(int)self->size()+1)
1172           self->insert(self->begin()+index, x);
1173         else
1174           throw std::out_of_range("index");
1175       }
1176 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1177         if (index>=0 && index<(int)self->size()+1)
1178           self->insert(self->begin()+index, values.begin(), values.end());
1179         else
1180           throw std::out_of_range("index");
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1183         if (index>=0 && index<(int)self->size())
1184           self->erase(self->begin() + index);
1185         else
1186           throw std::out_of_range("index");
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1189         if (index < 0)
1190           throw std::out_of_range("index");
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1194           throw std::invalid_argument("invalid range");
1195         self->erase(self->begin()+index, self->begin()+index+count);
1196       }
1197 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1198         if (count < 0)
1199           throw std::out_of_range("count");
1200         return new std::vector< unsigned int >(count, value);
1201       }
1202 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1203         std::reverse(self->begin(), self->end());
1204       }
1205 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1206         if (index < 0)
1207           throw std::out_of_range("index");
1208         if (count < 0)
1209           throw std::out_of_range("count");
1210         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1211           throw std::invalid_argument("invalid range");
1212         std::reverse(self->begin()+index, self->begin()+index+count);
1213       }
1214 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1215         if (index < 0)
1216           throw std::out_of_range("index");
1217         if (index+values.size() > self->size())
1218           throw std::out_of_range("index");
1219         std::copy(values.begin(), values.end(), self->begin()+index);
1220       }
1221 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1222         return std::find(self->begin(), self->end(), value) != self->end();
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1227         if (it != self->end())
1228           index = (int)(it - self->begin());
1229         return index;
1230       }
1231 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1232         int index = -1;
1233         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1234         if (rit != self->rend())
1235           index = (int)(self->rend() - 1 - rit);
1236         return index;
1237       }
1238 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1239         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1240         if (it != self->end()) {
1241           self->erase(it);
1242           return true;
1243         }
1244         return false;
1245       }
1246 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1247         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1248         if (capacity >= 0) {
1249           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1250           pv->reserve(capacity);
1251        } else {
1252           throw std::out_of_range("capacity");
1253        }
1254        return pv;
1255       }
1256 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1257         if (index>=0 && index<(int)self->size())
1258           return (*self)[index];
1259         else
1260           throw std::out_of_range("index");
1261       }
1262 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1263         if (index>=0 && index<(int)self->size())
1264           return (*self)[index];
1265         else
1266           throw std::out_of_range("index");
1267       }
1268 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1269         if (index>=0 && index<(int)self->size())
1270           (*self)[index] = val;
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1275         self->insert(self->end(), values.begin(), values.end());
1276       }
1277 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1278         if (index < 0)
1279           throw std::out_of_range("index");
1280         if (count < 0)
1281           throw std::out_of_range("count");
1282         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1283           throw std::invalid_argument("invalid range");
1284         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1285       }
1286 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1287         if (index>=0 && index<(int)self->size()+1)
1288           self->insert(self->begin()+index, x);
1289         else
1290           throw std::out_of_range("index");
1291       }
1292 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1293         if (index>=0 && index<(int)self->size()+1)
1294           self->insert(self->begin()+index, values.begin(), values.end());
1295         else
1296           throw std::out_of_range("index");
1297       }
1298 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1299         if (index>=0 && index<(int)self->size())
1300           self->erase(self->begin() + index);
1301         else
1302           throw std::out_of_range("index");
1303       }
1304 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1305         if (index < 0)
1306           throw std::out_of_range("index");
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1310           throw std::invalid_argument("invalid range");
1311         self->erase(self->begin()+index, self->begin()+index+count);
1312       }
1313 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1314         if (count < 0)
1315           throw std::out_of_range("count");
1316         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1317       }
1318 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1319         std::reverse(self->begin(), self->end());
1320       }
1321 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1322         if (index < 0)
1323           throw std::out_of_range("index");
1324         if (count < 0)
1325           throw std::out_of_range("count");
1326         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1327           throw std::invalid_argument("invalid range");
1328         std::reverse(self->begin()+index, self->begin()+index+count);
1329       }
1330 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1331         if (index < 0)
1332           throw std::out_of_range("index");
1333         if (index+values.size() > self->size())
1334           throw std::out_of_range("index");
1335         std::copy(values.begin(), values.end(), self->begin()+index);
1336       }
1337 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1338         std::vector< Dali::Actor >* pv = 0;
1339         if (capacity >= 0) {
1340           pv = new std::vector< Dali::Actor >();
1341           pv->reserve(capacity);
1342        } else {
1343           throw std::out_of_range("capacity");
1344        }
1345        return pv;
1346       }
1347 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1348         if (index>=0 && index<(int)self->size())
1349           return (*self)[index];
1350         else
1351           throw std::out_of_range("index");
1352       }
1353 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1354         if (index>=0 && index<(int)self->size())
1355           return (*self)[index];
1356         else
1357           throw std::out_of_range("index");
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1360         if (index>=0 && index<(int)self->size())
1361           (*self)[index] = val;
1362         else
1363           throw std::out_of_range("index");
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1366         self->insert(self->end(), values.begin(), values.end());
1367       }
1368 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1369         if (index < 0)
1370           throw std::out_of_range("index");
1371         if (count < 0)
1372           throw std::out_of_range("count");
1373         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1374           throw std::invalid_argument("invalid range");
1375         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1378         if (index>=0 && index<(int)self->size()+1)
1379           self->insert(self->begin()+index, x);
1380         else
1381           throw std::out_of_range("index");
1382       }
1383 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1384         if (index>=0 && index<(int)self->size()+1)
1385           self->insert(self->begin()+index, values.begin(), values.end());
1386         else
1387           throw std::out_of_range("index");
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1390         if (index>=0 && index<(int)self->size())
1391           self->erase(self->begin() + index);
1392         else
1393           throw std::out_of_range("index");
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1396         if (index < 0)
1397           throw std::out_of_range("index");
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1401           throw std::invalid_argument("invalid range");
1402         self->erase(self->begin()+index, self->begin()+index+count);
1403       }
1404 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1405         if (count < 0)
1406           throw std::out_of_range("count");
1407         return new std::vector< Dali::Actor >(count, value);
1408       }
1409 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1410         std::reverse(self->begin(), self->end());
1411       }
1412 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1413         if (index < 0)
1414           throw std::out_of_range("index");
1415         if (count < 0)
1416           throw std::out_of_range("count");
1417         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1418           throw std::invalid_argument("invalid range");
1419         std::reverse(self->begin()+index, self->begin()+index+count);
1420       }
1421 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1422         if (index < 0)
1423           throw std::out_of_range("index");
1424         if (index+values.size() > self->size())
1425           throw std::out_of_range("index");
1426         std::copy(values.begin(), values.end(), self->begin()+index);
1427       }
1428 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1429          return self->Empty();
1430       }
1431 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1432         return self->GetConnectionCount();
1433       }
1434 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1435           self->Connect( func );
1436       }
1437 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1438           self->Disconnect( func );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1441           return self->Emit( arg );
1442       }
1443 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1444          return self->Empty();
1445       }
1446 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1447         return self->GetConnectionCount();
1448       }
1449 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1450         self->Connect( func );
1451       }
1452 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1453         self->Disconnect( func );
1454       }
1455 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1456         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1457 /*@SWIG@*/ self->Emit( arg1, arg2 );
1458       }
1459 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1460          return self->Empty();
1461       }
1462 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1463         return self->GetConnectionCount();
1464       }
1465 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1466         self->Connect( func );
1467       }
1468 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1469         self->Disconnect( func );
1470       }
1471 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1472         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1473 /*@SWIG@*/ self->Emit( arg1, arg2 );
1474       }
1475 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1476          return self->Empty();
1477       }
1478 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1479         return self->GetConnectionCount();
1480       }
1481 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1482         self->Connect( func );
1483       }
1484 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1485         self->Disconnect( func );
1486       }
1487 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1488         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1489 /*@SWIG@*/ self->Emit( arg1, arg2 );
1490       }
1491 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1492          return self->Empty();
1493       }
1494 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1495         return self->GetConnectionCount();
1496       }
1497 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1498         self->Connect( func );
1499       }
1500 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1501         self->Disconnect( func );
1502       }
1503 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1504         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1505 /*@SWIG@*/ self->Emit( arg1, arg2 );
1506       }
1507 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1508          return self->Empty();
1509       }
1510 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1511         return self->GetConnectionCount();
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1514           self->Connect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1517           self->Disconnect( func );
1518       }
1519 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1520           return self->Emit( arg );
1521       }
1522 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1523          return self->Empty();
1524       }
1525 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1526         return self->GetConnectionCount();
1527       }
1528 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1529           self->Connect( func );
1530       }
1531 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1532           self->Disconnect( func );
1533       }
1534 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1535           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1536 /*@SWIG@*/ self->Emit( arg );
1537       }
1538 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1539          return self->Empty();
1540       }
1541 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1542         return self->GetConnectionCount();
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1545           return self->Connect( func );
1546       }
1547 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1548           self->Disconnect( func );
1549       }
1550 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1551           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1552 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1553       }
1554 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1555          return self->Empty();
1556       }
1557 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1558         return self->GetConnectionCount();
1559       }
1560 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1561           self->Connect( func );
1562       }
1563 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1564           self->Disconnect( func );
1565       }
1566 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1567           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1568 /*@SWIG@*/ self->Emit( arg );
1569       }
1570 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1571          return self->Empty();
1572       }
1573 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1574         return self->GetConnectionCount();
1575       }
1576 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1577           return self->Connect( func );
1578       }
1579 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1580           self->Disconnect( func );
1581       }
1582 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1583           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1584 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1585       }
1586 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1587          return self->Empty();
1588       }
1589 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1590         return self->GetConnectionCount();
1591       }
1592 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1593           self->Connect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1596           self->Disconnect( func );
1597       }
1598 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1599           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1600 /*@SWIG@*/ self->Emit( arg );
1601       }
1602 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1603          return self->Empty();
1604       }
1605 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1606         return self->GetConnectionCount();
1607       }
1608 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1609           self->Connect( func );
1610       }
1611 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1612           self->Disconnect( func );
1613       }
1614 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1615           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1616 /*@SWIG@*/ self->Emit( arg );
1617       }
1618
1619
1620 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1621          return self->Empty();
1622       }
1623 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1624         return self->GetConnectionCount();
1625       }
1626 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1627         self->Connect( func );
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1630         self->Disconnect( func );
1631       }
1632 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1633         return self->Emit( arg1, arg2 );
1634       }
1635 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1636          return self->Empty();
1637       }
1638 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1639         return self->GetConnectionCount();
1640       }
1641 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1642           self->Connect( func );
1643       }
1644 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1645           self->Disconnect( func );
1646       }
1647 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1648           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1649 /*@SWIG@*/ self->Emit( arg );
1650       }
1651 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1652          return self->Empty();
1653       }
1654 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1655         return self->GetConnectionCount();
1656       }
1657 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1658           self->Connect( func );
1659       }
1660 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1661           self->Disconnect( func );
1662       }
1663 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1664           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1665 /*@SWIG@*/ self->Emit( arg );
1666       }
1667 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1668          return self->Empty();
1669       }
1670 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1671         return self->GetConnectionCount();
1672       }
1673 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1674         self->Connect( func );
1675       }
1676 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1677         self->Disconnect( func );
1678       }
1679 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1680         return self->Emit( arg1, arg2 );
1681       }
1682 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1683          return self->Empty();
1684       }
1685 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1686         return self->GetConnectionCount();
1687       }
1688 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1689         self->Connect( func );
1690       }
1691 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1692         self->Disconnect( func );
1693       }
1694 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1695         return self->Emit( arg1, arg2 );
1696       }
1697
1698 /* ---------------------------------------------------
1699  * C++ director class methods
1700  * --------------------------------------------------- */
1701
1702 #include "dali_wrap.h"
1703
1704 /*
1705  *  Widget director
1706  */
1707 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1708   swig_init_callbacks();
1709 }
1710
1711 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1712 }
1713
1714 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1715   char * jcontentInfo = 0 ;
1716   void * jwindow  ;
1717
1718   if (!swig_callbackOnCreate) {
1719     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1720     return;
1721   } else {
1722     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1723     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1724     swig_callbackOnCreate(jcontentInfo, jwindow);
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1729   char * jcontentInfo = 0 ;
1730   int jtype  ;
1731
1732   if (!swig_callbackOnTerminate) {
1733     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1734     return;
1735   } else {
1736     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1737     jtype = (int)type;
1738     swig_callbackOnTerminate(jcontentInfo, jtype);
1739   }
1740 }
1741
1742 void SwigDirector_WidgetImpl::OnPause() {
1743   if (!swig_callbackOnPause) {
1744     Dali::Internal::Adaptor::Widget::OnPause();
1745     return;
1746   } else {
1747     swig_callbackOnPause();
1748   }
1749 }
1750
1751 void SwigDirector_WidgetImpl::OnResume() {
1752   if (!swig_callbackOnResume) {
1753     Dali::Internal::Adaptor::Widget::OnResume();
1754     return;
1755   } else {
1756     swig_callbackOnResume();
1757   }
1758 }
1759
1760 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1761   void * jwindow  ;
1762
1763   if (!swig_callbackOnResize) {
1764     Dali::Internal::Adaptor::Widget::OnResize(window);
1765     return;
1766   } else {
1767     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1768     swig_callbackOnResize(jwindow);
1769   }
1770 }
1771
1772 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1773   char * jcontentInfo = 0 ;
1774   int jforce  ;
1775
1776   if (!swig_callbackOnUpdate) {
1777     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1778     return;
1779   } else {
1780     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1781     jforce = force;
1782     swig_callbackOnUpdate(jcontentInfo, jforce);
1783   }
1784 }
1785
1786 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1787   void * jslotObserver = 0 ;
1788   void * jcallback = 0 ;
1789
1790   if (!swig_callbackSignalConnected) {
1791     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1792     return;
1793   } else {
1794     jslotObserver = (void *) slotObserver;
1795     jcallback = (void *) callback;
1796     swig_callbackSignalConnected(jslotObserver, jcallback);
1797   }
1798 }
1799
1800 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1801   void * jslotObserver = 0 ;
1802   void * jcallback = 0 ;
1803
1804   if (!swig_callbackSignalDisconnected) {
1805     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1806     return;
1807   } else {
1808     jslotObserver = (void *) slotObserver;
1809     jcallback = (void *) callback;
1810     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1811   }
1812 }
1813
1814 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1815
1816   swig_callbackOnCreate = callbackOnCreate;
1817   swig_callbackOnTerminate = callbackOnTerminate;
1818   swig_callbackOnPause = callbackOnPause;
1819   swig_callbackOnResume = callbackOnResume;
1820   swig_callbackOnResize = callbackOnResize;
1821   swig_callbackOnUpdate = callbackOnUpdate;
1822   swig_callbackSignalConnected = callbackSignalConnected;
1823   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1824 }
1825
1826 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1827   swig_callbackOnCreate = 0;
1828   swig_callbackOnTerminate = 0;
1829   swig_callbackOnPause = 0;
1830   swig_callbackOnResume = 0;
1831   swig_callbackOnResize = 0;
1832   swig_callbackOnUpdate = 0;
1833   swig_callbackSignalConnected = 0;
1834   swig_callbackSignalDisconnected = 0;
1835 }
1836
1837
1838 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1839   swig_init_callbacks();
1840 }
1841
1842 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1843
1844 }
1845
1846
1847 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1848   int jdepth  ;
1849
1850   if (!swig_callbackOnStageConnection) {
1851     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1852     return;
1853   } else {
1854     jdepth = depth;
1855     swig_callbackOnStageConnection(jdepth);
1856   }
1857 }
1858
1859 void SwigDirector_ViewImpl::OnStageDisconnection() {
1860   if (!swig_callbackOnStageDisconnection) {
1861     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1862     return;
1863   } else {
1864     swig_callbackOnStageDisconnection();
1865   }
1866 }
1867
1868 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1869   void * jchild = 0 ;
1870
1871   if (!swig_callbackOnChildAdd) {
1872     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1873     return;
1874   } else {
1875     jchild = (Dali::Actor *) &child;
1876     swig_callbackOnChildAdd(jchild);
1877   }
1878 }
1879
1880 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1881   void * jchild = 0 ;
1882
1883   if (!swig_callbackOnChildRemove) {
1884     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1885     return;
1886   } else {
1887     jchild = (Dali::Actor *) &child;
1888     swig_callbackOnChildRemove(jchild);
1889   }
1890 }
1891
1892 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1893   int jindex  ;
1894   void * jpropertyValue  ;
1895
1896   if (!swig_callbackOnPropertySet) {
1897     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1898     return;
1899   } else {
1900     jindex = index;
1901     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1902     swig_callbackOnPropertySet(jindex, jpropertyValue);
1903   }
1904 }
1905
1906 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1907   void * jtargetSize = 0 ;
1908
1909   if (!swig_callbackOnSizeSet) {
1910     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1911     return;
1912   } else {
1913     jtargetSize = (Dali::Vector3 *) &targetSize;
1914     swig_callbackOnSizeSet(jtargetSize);
1915   }
1916 }
1917
1918 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1919   void * janimation = 0 ;
1920   void * jtargetSize = 0 ;
1921
1922   if (!swig_callbackOnSizeAnimation) {
1923     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1924     return;
1925   } else {
1926     janimation = (Dali::Animation *) &animation;
1927     jtargetSize = (Dali::Vector3 *) &targetSize;
1928     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1929   }
1930 }
1931
1932 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1933   bool c_result = SwigValueInit< bool >() ;
1934   unsigned int jresult = 0 ;
1935   void * jarg0 = 0 ;
1936
1937   if (!swig_callbackOnTouchEvent) {
1938     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1939   } else {
1940     jarg0 = (Dali::TouchEvent *) &event;
1941     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1942     c_result = jresult ? true : false;
1943   }
1944   return c_result;
1945 }
1946
1947 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1948   bool c_result = SwigValueInit< bool >() ;
1949   unsigned int jresult = 0 ;
1950   void * jarg0 = 0 ;
1951
1952   if (!swig_callbackOnHoverEvent) {
1953     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1954   } else {
1955     jarg0 = (Dali::HoverEvent *) &event;
1956     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1957     c_result = jresult ? true : false;
1958   }
1959   return c_result;
1960 }
1961
1962 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1963   bool c_result = SwigValueInit< bool >() ;
1964   unsigned int jresult = 0 ;
1965   void * jarg0 = 0 ;
1966
1967   if (!swig_callbackOnKeyEvent) {
1968     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1969   } else {
1970     jarg0 = (Dali::KeyEvent *) &event;
1971     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1972     c_result = jresult ? true : false;
1973   }
1974   return c_result;
1975 }
1976
1977 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1978   bool c_result = SwigValueInit< bool >() ;
1979   unsigned int jresult = 0 ;
1980   void * jarg0 = 0 ;
1981
1982   if (!swig_callbackOnWheelEvent) {
1983     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1984   } else {
1985     jarg0 = (Dali::WheelEvent *) &event;
1986     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1987     c_result = jresult ? true : false;
1988   }
1989   return c_result;
1990 }
1991
1992 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1993   void * jsize = 0 ;
1994   void * jcontainer = 0 ;
1995
1996   if (!swig_callbackOnRelayout) {
1997     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1998     return;
1999   } else {
2000     jsize = (Dali::Vector2 *) &size;
2001     jcontainer = (Dali::RelayoutContainer *) &container;
2002     swig_callbackOnRelayout(jsize, jcontainer);
2003   }
2004 }
2005
2006 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2007   int jpolicy  ;
2008   int jdimension  ;
2009
2010   if (!swig_callbackOnSetResizePolicy) {
2011     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2012     return;
2013   } else {
2014     jpolicy = (int)policy;
2015     jdimension = (int)dimension;
2016     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2017   }
2018 }
2019
2020 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2021   Dali::Vector3 c_result ;
2022   void * jresult = 0 ;
2023
2024   if (!swig_callbackGetNaturalSize) {
2025     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2026   } else {
2027     jresult = (void *) swig_callbackGetNaturalSize();
2028     if (!jresult) {
2029       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2030       return c_result;
2031     }
2032     c_result = *(Dali::Vector3 *)jresult;
2033   }
2034   return c_result;
2035 }
2036
2037 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2038   float c_result = SwigValueInit< float >() ;
2039   float jresult = 0 ;
2040   void * jchild = 0 ;
2041   int jdimension  ;
2042
2043   if (!swig_callbackCalculateChildSize) {
2044     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2045   } else {
2046     jchild = (Dali::Actor *) &child;
2047     jdimension = (int)dimension;
2048     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2049     c_result = (float)jresult;
2050   }
2051   return c_result;
2052 }
2053
2054 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2055   float c_result = SwigValueInit< float >() ;
2056   float jresult = 0 ;
2057   float jwidth  ;
2058
2059   if (!swig_callbackGetHeightForWidth) {
2060     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2061   } else {
2062     jwidth = width;
2063     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2064     c_result = (float)jresult;
2065   }
2066   return c_result;
2067 }
2068
2069 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2070   float c_result = SwigValueInit< float >() ;
2071   float jresult = 0 ;
2072   float jheight  ;
2073
2074   if (!swig_callbackGetWidthForHeight) {
2075     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2076   } else {
2077     jheight = height;
2078     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2079     c_result = (float)jresult;
2080   }
2081   return c_result;
2082 }
2083
2084 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2085   bool c_result = SwigValueInit< bool >() ;
2086   unsigned int jresult = 0 ;
2087   int jdimension  ;
2088
2089   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2090     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2091   } else {
2092     jdimension = (int)dimension;
2093     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2094     c_result = jresult ? true : false;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2100   int jdimension  ;
2101
2102   if (!swig_callbackOnCalculateRelayoutSize) {
2103     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2104     return;
2105   } else {
2106     jdimension = (int)dimension;
2107     swig_callbackOnCalculateRelayoutSize(jdimension);
2108   }
2109 }
2110
2111 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2112   float jsize  ;
2113   int jdimension  ;
2114
2115   if (!swig_callbackOnLayoutNegotiated) {
2116     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2117     return;
2118   } else {
2119     jsize = size;
2120     jdimension = (int)dimension;
2121     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2122   }
2123 }
2124
2125 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2126   return Dali::CustomActorImpl::GetExtension();
2127 }
2128
2129 void SwigDirector_ViewImpl::OnInitialize() {
2130   if (!swig_callbackOnInitialize) {
2131     Dali::Toolkit::Internal::Control::OnInitialize();
2132     return;
2133   } else {
2134     swig_callbackOnInitialize();
2135   }
2136 }
2137
2138 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2139   void * jchild = 0 ;
2140
2141   if (!swig_callbackOnControlChildAdd) {
2142     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2143     return;
2144   } else {
2145     jchild = (Dali::Actor *) &child;
2146     swig_callbackOnControlChildAdd(jchild);
2147   }
2148 }
2149
2150 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2151   void * jchild = 0 ;
2152
2153   if (!swig_callbackOnControlChildRemove) {
2154     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2155     return;
2156   } else {
2157     jchild = (Dali::Actor *) &child;
2158     swig_callbackOnControlChildRemove(jchild);
2159   }
2160 }
2161
2162 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2163   void * jstyleManager  ;
2164   int jchange  ;
2165
2166   if (!swig_callbackOnStyleChange) {
2167     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2168     return;
2169   } else {
2170     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2171     jchange = (int)change;
2172     swig_callbackOnStyleChange(jstyleManager, jchange);
2173   }
2174 }
2175
2176 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2177   bool c_result = SwigValueInit< bool >() ;
2178   unsigned int jresult = 0 ;
2179
2180   if (!swig_callbackOnAccessibilityActivated) {
2181     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2182   } else {
2183     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2184     c_result = jresult ? true : false;
2185   }
2186   return c_result;
2187 }
2188
2189 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2190   bool c_result = SwigValueInit< bool >() ;
2191   unsigned int jresult = 0 ;
2192   void * jgesture  ;
2193
2194   if (!swig_callbackOnAccessibilityPan) {
2195     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2196   } else {
2197     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2198     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2199     c_result = jresult ? true : false;
2200   }
2201   return c_result;
2202 }
2203
2204 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2205   bool c_result = SwigValueInit< bool >() ;
2206   unsigned int jresult = 0 ;
2207   void * jtouchEvent = 0 ;
2208
2209   if (!swig_callbackOnAccessibilityTouch) {
2210     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2211   } else {
2212     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2213     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2214     c_result = jresult ? true : false;
2215   }
2216   return c_result;
2217 }
2218
2219 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2220   bool c_result = SwigValueInit< bool >() ;
2221   unsigned int jresult = 0 ;
2222   unsigned int jisIncrease  ;
2223
2224   if (!swig_callbackOnAccessibilityValueChange) {
2225     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2226   } else {
2227     jisIncrease = isIncrease;
2228     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2229     c_result = jresult ? true : false;
2230   }
2231   return c_result;
2232 }
2233
2234 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2235   bool c_result = SwigValueInit< bool >() ;
2236   unsigned int jresult = 0 ;
2237
2238   if (!swig_callbackOnAccessibilityZoom) {
2239     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2240   } else {
2241     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2242     c_result = jresult ? true : false;
2243   }
2244   return c_result;
2245 }
2246
2247 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2248   if (!swig_callbackOnKeyInputFocusGained) {
2249     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2250     return;
2251   } else {
2252     swig_callbackOnKeyInputFocusGained();
2253   }
2254 }
2255
2256 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2257   if (!swig_callbackOnKeyInputFocusLost) {
2258     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2259     return;
2260   } else {
2261     swig_callbackOnKeyInputFocusLost();
2262   }
2263 }
2264
2265 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2266   Dali::Actor c_result ;
2267   void * jresult = 0 ;
2268   void * jcurrentFocusedActor  ;
2269   int jdirection  ;
2270   unsigned int jloopEnabled  ;
2271
2272   if (!swig_callbackGetNextKeyboardFocusableActor) {
2273     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2274   } else {
2275     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2276     jdirection = (int)direction;
2277     jloopEnabled = loopEnabled;
2278     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2279     if (!jresult) {
2280       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2281       return c_result;
2282     }
2283     c_result = *(Dali::Actor *)jresult;
2284   }
2285   return c_result;
2286 }
2287
2288 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2289   void * jcommitedFocusableActor  ;
2290
2291   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2292     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2293     return;
2294   } else {
2295     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2296     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2297   }
2298 }
2299
2300 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2301   bool c_result = SwigValueInit< bool >() ;
2302   unsigned int jresult = 0 ;
2303
2304   if (!swig_callbackOnKeyboardEnter) {
2305     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2306   } else {
2307     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2308     c_result = jresult ? true : false;
2309   }
2310   return c_result;
2311 }
2312
2313 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2314   void * jpinch = 0 ;
2315
2316   if (!swig_callbackOnPinch) {
2317     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2318     return;
2319   } else {
2320     jpinch = (Dali::PinchGesture *) &pinch;
2321     swig_callbackOnPinch(jpinch);
2322   }
2323 }
2324
2325 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2326   void * jpan = 0 ;
2327
2328   if (!swig_callbackOnPan) {
2329     Dali::Toolkit::Internal::Control::OnPan(pan);
2330     return;
2331   } else {
2332     jpan = (Dali::PanGesture *) &pan;
2333     swig_callbackOnPan(jpan);
2334   }
2335 }
2336
2337 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2338   void * jtap = 0 ;
2339
2340   if (!swig_callbackOnTap) {
2341     Dali::Toolkit::Internal::Control::OnTap(tap);
2342     return;
2343   } else {
2344     jtap = (Dali::TapGesture *) &tap;
2345     swig_callbackOnTap(jtap);
2346   }
2347 }
2348
2349 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2350   void * jlongPress = 0 ;
2351
2352   if (!swig_callbackOnLongPress) {
2353     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2354     return;
2355   } else {
2356     jlongPress = (Dali::LongPressGesture *) &longPress;
2357     swig_callbackOnLongPress(jlongPress);
2358   }
2359 }
2360
2361 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2362   void * jslotObserver = 0 ;
2363   void * jcallback = 0 ;
2364
2365   if (!swig_callbackSignalConnected) {
2366     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2367     return;
2368   } else {
2369     jslotObserver = (void *) slotObserver;
2370     jcallback = (void *) callback;
2371     swig_callbackSignalConnected(jslotObserver, jcallback);
2372   }
2373 }
2374
2375 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2376   void * jslotObserver = 0 ;
2377   void * jcallback = 0 ;
2378
2379   if (!swig_callbackSignalDisconnected) {
2380     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2381     return;
2382   } else {
2383     jslotObserver = (void *) slotObserver;
2384     jcallback = (void *) callback;
2385     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2386   }
2387 }
2388
2389 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2390   return Dali::Toolkit::Internal::Control::GetControlExtension();
2391 }
2392
2393 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2394   swig_callbackOnStageConnection = callbackOnStageConnection;
2395   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2396   swig_callbackOnChildAdd = callbackOnChildAdd;
2397   swig_callbackOnChildRemove = callbackOnChildRemove;
2398   swig_callbackOnPropertySet = callbackOnPropertySet;
2399   swig_callbackOnSizeSet = callbackOnSizeSet;
2400   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2401   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2402   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2403   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2404   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2405   swig_callbackOnRelayout = callbackOnRelayout;
2406   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2407   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2408   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2409   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2410   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2411   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2412   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2413   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2414   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2415   swig_callbackOnInitialize = callbackOnInitialize;
2416   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2417   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2418   swig_callbackOnStyleChange = callbackOnStyleChange;
2419   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2420   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2421   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2422   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2423   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2424   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2425   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2426   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2427   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2428   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2429   swig_callbackOnPinch = callbackOnPinch;
2430   swig_callbackOnPan = callbackOnPan;
2431   swig_callbackOnTap = callbackOnTap;
2432   swig_callbackOnLongPress = callbackOnLongPress;
2433   swig_callbackSignalConnected = callbackSignalConnected;
2434   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2435 }
2436
2437 void SwigDirector_ViewImpl::swig_init_callbacks() {
2438   swig_callbackOnStageConnection = 0;
2439   swig_callbackOnStageDisconnection = 0;
2440   swig_callbackOnChildAdd = 0;
2441   swig_callbackOnChildRemove = 0;
2442   swig_callbackOnPropertySet = 0;
2443   swig_callbackOnSizeSet = 0;
2444   swig_callbackOnSizeAnimation = 0;
2445   swig_callbackOnTouchEvent = 0;
2446   swig_callbackOnHoverEvent = 0;
2447   swig_callbackOnKeyEvent = 0;
2448   swig_callbackOnWheelEvent = 0;
2449   swig_callbackOnRelayout = 0;
2450   swig_callbackOnSetResizePolicy = 0;
2451   swig_callbackGetNaturalSize = 0;
2452   swig_callbackCalculateChildSize = 0;
2453   swig_callbackGetHeightForWidth = 0;
2454   swig_callbackGetWidthForHeight = 0;
2455   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2456   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2457   swig_callbackOnCalculateRelayoutSize = 0;
2458   swig_callbackOnLayoutNegotiated = 0;
2459   swig_callbackOnInitialize = 0;
2460   swig_callbackOnControlChildAdd = 0;
2461   swig_callbackOnControlChildRemove = 0;
2462   swig_callbackOnStyleChange = 0;
2463   swig_callbackOnAccessibilityActivated = 0;
2464   swig_callbackOnAccessibilityPan = 0;
2465   swig_callbackOnAccessibilityTouch = 0;
2466   swig_callbackOnAccessibilityValueChange = 0;
2467   swig_callbackOnAccessibilityZoom = 0;
2468   swig_callbackOnKeyInputFocusGained = 0;
2469   swig_callbackOnKeyInputFocusLost = 0;
2470   swig_callbackGetNextKeyboardFocusableActor = 0;
2471   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2472   swig_callbackOnKeyboardEnter = 0;
2473   swig_callbackOnPinch = 0;
2474   swig_callbackOnPan = 0;
2475   swig_callbackOnTap = 0;
2476   swig_callbackOnLongPress = 0;
2477   swig_callbackSignalConnected = 0;
2478   swig_callbackSignalDisconnected = 0;
2479 }
2480
2481 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2482   swig_init_callbacks();
2483 }
2484
2485 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2486
2487 }
2488
2489
2490 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2491   unsigned int c_result = SwigValueInit< unsigned int >() ;
2492   unsigned int jresult = 0 ;
2493
2494   if (!swig_callbackGetNumberOfItems) {
2495     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2496   } else {
2497     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2498     c_result = (unsigned int)jresult;
2499   }
2500   return c_result;
2501 }
2502
2503 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2504   Dali::Actor c_result ;
2505   void * jresult = 0 ;
2506   unsigned int jitemId  ;
2507
2508   if (!swig_callbackNewItem) {
2509     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2510   } else {
2511     jitemId = itemId;
2512     jresult = (void *) swig_callbackNewItem(jitemId);
2513     if (!jresult) {
2514       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2515       return c_result;
2516     }
2517     c_result = *(Dali::Actor *)jresult;
2518   }
2519   return c_result;
2520 }
2521
2522 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2523   unsigned int jitemId  ;
2524   void * jactor  ;
2525
2526   if (!swig_callbackItemReleased) {
2527     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2528     return;
2529   } else {
2530     jitemId = itemId;
2531     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2532     swig_callbackItemReleased(jitemId, jactor);
2533   }
2534 }
2535
2536 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2537   return Dali::Toolkit::ItemFactory::GetExtension();
2538 }
2539
2540 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2541   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2542   swig_callbackNewItem = callbackNewItem;
2543   swig_callbackItemReleased = callbackItemReleased;
2544 }
2545
2546 void SwigDirector_ItemFactory::swig_init_callbacks() {
2547   swig_callbackGetNumberOfItems = 0;
2548   swig_callbackNewItem = 0;
2549   swig_callbackItemReleased = 0;
2550 }
2551
2552 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2553   swig_init_callbacks();
2554 }
2555
2556 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2557
2558 }
2559
2560
2561 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2562   Dali::Actor c_result ;
2563   void * jresult = 0 ;
2564   void * jcurrent  ;
2565   void * jproposed  ;
2566   int jdirection  ;
2567
2568   if (!swig_callbackGetNextFocusableActor) {
2569     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2570   } else {
2571     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2572     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2573     jdirection = (int)direction;
2574     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2575     if (!jresult) {
2576       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2577       return c_result;
2578     }
2579     c_result = *(Dali::Actor *)jresult;
2580   }
2581   return c_result;
2582 }
2583
2584 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2585   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2586 }
2587
2588 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2589   swig_callbackGetNextFocusableActor = 0;
2590 }
2591
2592
2593 #ifdef __cplusplus
2594 extern "C" {
2595 #endif
2596
2597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2598   void * jresult ;
2599   floatp *result = 0 ;
2600
2601   {
2602     try {
2603       result = (floatp *)new_floatp();
2604     } catch (std::out_of_range& e) {
2605       {
2606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2607       };
2608     } catch (std::exception& e) {
2609       {
2610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2611       };
2612     } catch (DaliException e) {
2613       {
2614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2615       };
2616     } catch (...) {
2617       {
2618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2619       };
2620     }
2621   }
2622   jresult = (void *)result;
2623   return jresult;
2624 }
2625
2626
2627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2628   floatp *arg1 = (floatp *) 0 ;
2629
2630   arg1 = (floatp *)jarg1;
2631   {
2632     try {
2633       delete_floatp(arg1);
2634     } catch (std::out_of_range& e) {
2635       {
2636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2637       };
2638     } catch (std::exception& e) {
2639       {
2640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2641       };
2642     } catch (Dali::DaliException e) {
2643       {
2644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2645       };
2646     } catch (...) {
2647       {
2648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2649       };
2650     }
2651   }
2652
2653 }
2654
2655
2656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2657   floatp *arg1 = (floatp *) 0 ;
2658   float arg2 ;
2659
2660   arg1 = (floatp *)jarg1;
2661   arg2 = (float)jarg2;
2662   {
2663     try {
2664       floatp_assign(arg1,arg2);
2665     } catch (std::out_of_range& e) {
2666       {
2667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2668       };
2669     } catch (std::exception& e) {
2670       {
2671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2672       };
2673     } catch (Dali::DaliException e) {
2674       {
2675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2676       };
2677     } catch (...) {
2678       {
2679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2680       };
2681     }
2682   }
2683
2684 }
2685
2686
2687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2688   float jresult ;
2689   floatp *arg1 = (floatp *) 0 ;
2690   float result;
2691
2692   arg1 = (floatp *)jarg1;
2693   {
2694     try {
2695       result = (float)floatp_value(arg1);
2696     } catch (std::out_of_range& e) {
2697       {
2698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2699       };
2700     } catch (std::exception& e) {
2701       {
2702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2703       };
2704     } catch (DaliException e) {
2705       {
2706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2707       };
2708     } catch (...) {
2709       {
2710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2711       };
2712     }
2713   }
2714   jresult = result;
2715   return jresult;
2716 }
2717
2718
2719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2720   void * jresult ;
2721   floatp *arg1 = (floatp *) 0 ;
2722   float *result = 0 ;
2723
2724   arg1 = (floatp *)jarg1;
2725   {
2726     try {
2727       result = (float *)floatp_cast(arg1);
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (Dali::DaliException e) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2739       };
2740     } catch (...) {
2741       {
2742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2743       };
2744     }
2745   }
2746
2747   jresult = (void *)result;
2748   return jresult;
2749 }
2750
2751
2752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2753   void * jresult ;
2754   float *arg1 = (float *) 0 ;
2755   floatp *result = 0 ;
2756
2757   arg1 = (float *)jarg1;
2758   {
2759     try {
2760       result = (floatp *)floatp_frompointer(arg1);
2761     } catch (std::out_of_range& e) {
2762       {
2763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2764       };
2765     } catch (std::exception& e) {
2766       {
2767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2768       };
2769     } catch (Dali::DaliException e) {
2770       {
2771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2772       };
2773     } catch (...) {
2774       {
2775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2776       };
2777     }
2778   }
2779
2780   jresult = (void *)result;
2781   return jresult;
2782 }
2783
2784
2785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2786   void * jresult ;
2787   intp *result = 0 ;
2788
2789   {
2790     try {
2791       result = (intp *)new_intp();
2792     } catch (std::out_of_range& e) {
2793       {
2794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2795       };
2796     } catch (std::exception& e) {
2797       {
2798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2799       };
2800     } catch (Dali::DaliException e) {
2801       {
2802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2803       };
2804     } catch (...) {
2805       {
2806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2807       };
2808     }
2809   }
2810
2811   jresult = (void *)result;
2812   return jresult;
2813 }
2814
2815
2816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2817   intp *arg1 = (intp *) 0 ;
2818
2819   arg1 = (intp *)jarg1;
2820   {
2821     try {
2822       delete_intp(arg1);
2823     } catch (std::out_of_range& e) {
2824       {
2825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2826       };
2827     } catch (std::exception& e) {
2828       {
2829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2830       };
2831     } catch (Dali::DaliException e) {
2832       {
2833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2834       };
2835     } catch (...) {
2836       {
2837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2838       };
2839     }
2840   }
2841
2842 }
2843
2844
2845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2846   intp *arg1 = (intp *) 0 ;
2847   int arg2 ;
2848
2849   arg1 = (intp *)jarg1;
2850   arg2 = (int)jarg2;
2851   {
2852     try {
2853       intp_assign(arg1,arg2);
2854     } catch (std::out_of_range& e) {
2855       {
2856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2857       };
2858     } catch (std::exception& e) {
2859       {
2860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2861       };
2862     } catch (Dali::DaliException e) {
2863       {
2864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2865       };
2866     } catch (...) {
2867       {
2868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2869       };
2870     }
2871   }
2872
2873 }
2874
2875
2876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2877   int jresult ;
2878   intp *arg1 = (intp *) 0 ;
2879   int result;
2880
2881   arg1 = (intp *)jarg1;
2882   {
2883     try {
2884       result = (int)intp_value(arg1);
2885     } catch (std::out_of_range& e) {
2886       {
2887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2888       };
2889     } catch (std::exception& e) {
2890       {
2891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2892       };
2893     } catch (Dali::DaliException e) {
2894       {
2895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2896       };
2897     } catch (...) {
2898       {
2899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2900       };
2901     }
2902   }
2903
2904   jresult = result;
2905   return jresult;
2906 }
2907
2908
2909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2910   void * jresult ;
2911   intp *arg1 = (intp *) 0 ;
2912   int *result = 0 ;
2913
2914   arg1 = (intp *)jarg1;
2915   {
2916     try {
2917       result = (int *)intp_cast(arg1);
2918     } catch (std::out_of_range& e) {
2919       {
2920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2921       };
2922     } catch (std::exception& e) {
2923       {
2924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2925       };
2926     } catch (Dali::DaliException e) {
2927       {
2928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2929       };
2930     } catch (...) {
2931       {
2932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2933       };
2934     }
2935   }
2936
2937   jresult = (void *)result;
2938   return jresult;
2939 }
2940
2941
2942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2943   void * jresult ;
2944   int *arg1 = (int *) 0 ;
2945   intp *result = 0 ;
2946
2947   arg1 = (int *)jarg1;
2948   {
2949     try {
2950       result = (intp *)intp_frompointer(arg1);
2951     } catch (std::out_of_range& e) {
2952       {
2953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2954       };
2955     } catch (std::exception& e) {
2956       {
2957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2958       };
2959     } catch (Dali::DaliException e) {
2960       {
2961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2962       };
2963     } catch (...) {
2964       {
2965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2966       };
2967     }
2968   }
2969
2970   jresult = (void *)result;
2971   return jresult;
2972 }
2973
2974
2975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2976   void * jresult ;
2977   doublep *result = 0 ;
2978
2979   {
2980     try {
2981       result = (doublep *)new_doublep();
2982     } catch (std::out_of_range& e) {
2983       {
2984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2985       };
2986     } catch (std::exception& e) {
2987       {
2988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2989       };
2990     } catch (Dali::DaliException e) {
2991       {
2992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2993       };
2994     } catch (...) {
2995       {
2996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2997       };
2998     }
2999   }
3000
3001   jresult = (void *)result;
3002   return jresult;
3003 }
3004
3005
3006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3007   doublep *arg1 = (doublep *) 0 ;
3008
3009   arg1 = (doublep *)jarg1;
3010   {
3011     try {
3012       delete_doublep(arg1);
3013     } catch (std::out_of_range& e) {
3014       {
3015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3016       };
3017     } catch (std::exception& e) {
3018       {
3019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3020       };
3021     } catch (Dali::DaliException e) {
3022       {
3023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3024       };
3025     } catch (...) {
3026       {
3027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3028       };
3029     }
3030   }
3031
3032 }
3033
3034
3035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3036   doublep *arg1 = (doublep *) 0 ;
3037   double arg2 ;
3038
3039   arg1 = (doublep *)jarg1;
3040   arg2 = (double)jarg2;
3041   {
3042     try {
3043       doublep_assign(arg1,arg2);
3044     } catch (std::out_of_range& e) {
3045       {
3046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3047       };
3048     } catch (std::exception& e) {
3049       {
3050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3051       };
3052     } catch (Dali::DaliException e) {
3053       {
3054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3059       };
3060     }
3061   }
3062
3063 }
3064
3065
3066 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3067   double jresult ;
3068   doublep *arg1 = (doublep *) 0 ;
3069   double result;
3070
3071   arg1 = (doublep *)jarg1;
3072   {
3073     try {
3074       result = (double)doublep_value(arg1);
3075     } catch (std::out_of_range& e) {
3076       {
3077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3078       };
3079     } catch (std::exception& e) {
3080       {
3081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3082       };
3083     } catch (Dali::DaliException e) {
3084       {
3085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3086       };
3087     } catch (...) {
3088       {
3089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3090       };
3091     }
3092   }
3093
3094   jresult = result;
3095   return jresult;
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3100   void * jresult ;
3101   doublep *arg1 = (doublep *) 0 ;
3102   double *result = 0 ;
3103
3104   arg1 = (doublep *)jarg1;
3105   {
3106     try {
3107       result = (double *)doublep_cast(arg1);
3108     } catch (std::out_of_range& e) {
3109       {
3110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3111       };
3112     } catch (std::exception& e) {
3113       {
3114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3115       };
3116     } catch (Dali::DaliException e) {
3117       {
3118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3119       };
3120     } catch (...) {
3121       {
3122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3123       };
3124     }
3125   }
3126
3127   jresult = (void *)result;
3128   return jresult;
3129 }
3130
3131
3132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3133   void * jresult ;
3134   double *arg1 = (double *) 0 ;
3135   doublep *result = 0 ;
3136
3137   arg1 = (double *)jarg1;
3138   {
3139     try {
3140       result = (doublep *)doublep_frompointer(arg1);
3141     } catch (std::out_of_range& e) {
3142       {
3143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3144       };
3145     } catch (std::exception& e) {
3146       {
3147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3148       };
3149     } catch (Dali::DaliException e) {
3150       {
3151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3152       };
3153     } catch (...) {
3154       {
3155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3156       };
3157     }
3158   }
3159
3160   jresult = (void *)result;
3161   return jresult;
3162 }
3163
3164
3165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3166   void * jresult ;
3167   uintp *result = 0 ;
3168
3169   {
3170     try {
3171       result = (uintp *)new_uintp();
3172     } catch (std::out_of_range& e) {
3173       {
3174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3175       };
3176     } catch (std::exception& e) {
3177       {
3178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3179       };
3180     } catch (Dali::DaliException e) {
3181       {
3182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3183       };
3184     } catch (...) {
3185       {
3186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3187       };
3188     }
3189   }
3190
3191   jresult = (void *)result;
3192   return jresult;
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3197   uintp *arg1 = (uintp *) 0 ;
3198
3199   arg1 = (uintp *)jarg1;
3200   {
3201     try {
3202       delete_uintp(arg1);
3203     } catch (std::out_of_range& e) {
3204       {
3205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3206       };
3207     } catch (std::exception& e) {
3208       {
3209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3210       };
3211     } catch (Dali::DaliException e) {
3212       {
3213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3214       };
3215     } catch (...) {
3216       {
3217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3218       };
3219     }
3220   }
3221
3222 }
3223
3224
3225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3226   uintp *arg1 = (uintp *) 0 ;
3227   unsigned int arg2 ;
3228
3229   arg1 = (uintp *)jarg1;
3230   arg2 = (unsigned int)jarg2;
3231   {
3232     try {
3233       uintp_assign(arg1,arg2);
3234     } catch (std::out_of_range& e) {
3235       {
3236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3237       };
3238     } catch (std::exception& e) {
3239       {
3240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3241       };
3242     } catch (Dali::DaliException e) {
3243       {
3244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3245       };
3246     } catch (...) {
3247       {
3248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3249       };
3250     }
3251   }
3252
3253 }
3254
3255
3256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3257   unsigned int jresult ;
3258   uintp *arg1 = (uintp *) 0 ;
3259   unsigned int result;
3260
3261   arg1 = (uintp *)jarg1;
3262   {
3263     try {
3264       result = (unsigned int)uintp_value(arg1);
3265     } catch (std::out_of_range& e) {
3266       {
3267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3268       };
3269     } catch (std::exception& e) {
3270       {
3271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3272       };
3273     } catch (Dali::DaliException e) {
3274       {
3275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3276       };
3277     } catch (...) {
3278       {
3279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3280       };
3281     }
3282   }
3283
3284   jresult = result;
3285   return jresult;
3286 }
3287
3288
3289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3290   void * jresult ;
3291   uintp *arg1 = (uintp *) 0 ;
3292   unsigned int *result = 0 ;
3293
3294   arg1 = (uintp *)jarg1;
3295   {
3296     try {
3297       result = (unsigned int *)uintp_cast(arg1);
3298     } catch (std::out_of_range& e) {
3299       {
3300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3301       };
3302     } catch (std::exception& e) {
3303       {
3304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3305       };
3306     } catch (Dali::DaliException e) {
3307       {
3308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3309       };
3310     } catch (...) {
3311       {
3312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3313       };
3314     }
3315   }
3316
3317   jresult = (void *)result;
3318   return jresult;
3319 }
3320
3321
3322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3323   void * jresult ;
3324   unsigned int *arg1 = (unsigned int *) 0 ;
3325   uintp *result = 0 ;
3326
3327   arg1 = (unsigned int *)jarg1;
3328   {
3329     try {
3330       result = (uintp *)uintp_frompointer(arg1);
3331     } catch (std::out_of_range& e) {
3332       {
3333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3334       };
3335     } catch (std::exception& e) {
3336       {
3337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3338       };
3339     } catch (Dali::DaliException e) {
3340       {
3341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3342       };
3343     } catch (...) {
3344       {
3345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3346       };
3347     }
3348   }
3349
3350   jresult = (void *)result;
3351   return jresult;
3352 }
3353
3354
3355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3356   void * jresult ;
3357   ushortp *result = 0 ;
3358
3359   {
3360     try {
3361       result = (ushortp *)new_ushortp();
3362     } catch (std::out_of_range& e) {
3363       {
3364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3365       };
3366     } catch (std::exception& e) {
3367       {
3368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3369       };
3370     } catch (Dali::DaliException e) {
3371       {
3372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3373       };
3374     } catch (...) {
3375       {
3376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3377       };
3378     }
3379   }
3380
3381   jresult = (void *)result;
3382   return jresult;
3383 }
3384
3385
3386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3387   ushortp *arg1 = (ushortp *) 0 ;
3388
3389   arg1 = (ushortp *)jarg1;
3390   {
3391     try {
3392       delete_ushortp(arg1);
3393     } catch (std::out_of_range& e) {
3394       {
3395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3396       };
3397     } catch (std::exception& e) {
3398       {
3399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3400       };
3401     } catch (Dali::DaliException e) {
3402       {
3403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3404       };
3405     } catch (...) {
3406       {
3407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3408       };
3409     }
3410   }
3411
3412 }
3413
3414
3415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3416   ushortp *arg1 = (ushortp *) 0 ;
3417   unsigned short arg2 ;
3418
3419   arg1 = (ushortp *)jarg1;
3420   arg2 = (unsigned short)jarg2;
3421   {
3422     try {
3423       ushortp_assign(arg1,arg2);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3431       };
3432     } catch (Dali::DaliException e) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3435       };
3436     } catch (...) {
3437       {
3438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3439       };
3440     }
3441   }
3442
3443 }
3444
3445
3446 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3447   unsigned short jresult ;
3448   ushortp *arg1 = (ushortp *) 0 ;
3449   unsigned short result;
3450
3451   arg1 = (ushortp *)jarg1;
3452   {
3453     try {
3454       result = (unsigned short)ushortp_value(arg1);
3455     } catch (std::out_of_range& e) {
3456       {
3457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3458       };
3459     } catch (std::exception& e) {
3460       {
3461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3462       };
3463     } catch (Dali::DaliException e) {
3464       {
3465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3466       };
3467     } catch (...) {
3468       {
3469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3470       };
3471     }
3472   }
3473
3474   jresult = result;
3475   return jresult;
3476 }
3477
3478
3479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3480   void * jresult ;
3481   ushortp *arg1 = (ushortp *) 0 ;
3482   unsigned short *result = 0 ;
3483
3484   arg1 = (ushortp *)jarg1;
3485   {
3486     try {
3487       result = (unsigned short *)ushortp_cast(arg1);
3488     } catch (std::out_of_range& e) {
3489       {
3490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (std::exception& e) {
3493       {
3494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (Dali::DaliException e) {
3497       {
3498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3499       };
3500     } catch (...) {
3501       {
3502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3503       };
3504     }
3505   }
3506
3507   jresult = (void *)result;
3508   return jresult;
3509 }
3510
3511
3512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3513   void * jresult ;
3514   unsigned short *arg1 = (unsigned short *) 0 ;
3515   ushortp *result = 0 ;
3516
3517   arg1 = (unsigned short *)jarg1;
3518   {
3519     try {
3520       result = (ushortp *)ushortp_frompointer(arg1);
3521     } catch (std::out_of_range& e) {
3522       {
3523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3524       };
3525     } catch (std::exception& e) {
3526       {
3527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3528       };
3529     } catch (Dali::DaliException e) {
3530       {
3531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3532       };
3533     } catch (...) {
3534       {
3535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3536       };
3537     }
3538   }
3539
3540   jresult = (void *)result;
3541   return jresult;
3542 }
3543
3544
3545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3546   unsigned int jresult ;
3547   int arg1 ;
3548   unsigned int result;
3549
3550   arg1 = (int)jarg1;
3551   {
3552     try {
3553       result = (unsigned int)int_to_uint(arg1);
3554     } catch (std::out_of_range& e) {
3555       {
3556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3557       };
3558     } catch (std::exception& e) {
3559       {
3560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3561       };
3562     } catch (Dali::DaliException e) {
3563       {
3564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3565       };
3566     } catch (...) {
3567       {
3568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3569       };
3570     }
3571   }
3572
3573   jresult = result;
3574   return jresult;
3575 }
3576
3577
3578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3579   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3580
3581   arg1 = (Dali::RefObject *)jarg1;
3582   {
3583     try {
3584       (arg1)->Reference();
3585     } catch (std::out_of_range& e) {
3586       {
3587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3588       };
3589     } catch (std::exception& e) {
3590       {
3591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3592       };
3593     } catch (Dali::DaliException e) {
3594       {
3595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3596       };
3597     } catch (...) {
3598       {
3599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3600       };
3601     }
3602   }
3603
3604 }
3605
3606
3607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3608   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3609
3610   arg1 = (Dali::RefObject *)jarg1;
3611   {
3612     try {
3613       (arg1)->Unreference();
3614     } catch (std::out_of_range& e) {
3615       {
3616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3617       };
3618     } catch (std::exception& e) {
3619       {
3620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3621       };
3622     } catch (Dali::DaliException e) {
3623       {
3624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3625       };
3626     } catch (...) {
3627       {
3628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3629       };
3630     }
3631   }
3632
3633 }
3634
3635
3636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3637   int jresult ;
3638   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3639   int result;
3640
3641   arg1 = (Dali::RefObject *)jarg1;
3642   {
3643     try {
3644       result = (int)(arg1)->ReferenceCount();
3645     } catch (std::out_of_range& e) {
3646       {
3647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3648       };
3649     } catch (std::exception& e) {
3650       {
3651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3652       };
3653     } catch (Dali::DaliException e) {
3654       {
3655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3656       };
3657     } catch (...) {
3658       {
3659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3660       };
3661     }
3662   }
3663
3664   jresult = result;
3665   return jresult;
3666 }
3667
3668
3669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3670   void * jresult ;
3671   Dali::Any *result = 0 ;
3672
3673   {
3674     try {
3675       result = (Dali::Any *)new Dali::Any();
3676     } catch (std::out_of_range& e) {
3677       {
3678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3679       };
3680     } catch (std::exception& e) {
3681       {
3682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3683       };
3684     } catch (Dali::DaliException e) {
3685       {
3686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3687       };
3688     } catch (...) {
3689       {
3690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3691       };
3692     }
3693   }
3694
3695   jresult = (void *)result;
3696   return jresult;
3697 }
3698
3699
3700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3701   Dali::Any *arg1 = (Dali::Any *) 0 ;
3702
3703   arg1 = (Dali::Any *)jarg1;
3704   {
3705     try {
3706       delete arg1;
3707     } catch (std::out_of_range& e) {
3708       {
3709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3710       };
3711     } catch (std::exception& e) {
3712       {
3713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3714       };
3715     } catch (Dali::DaliException e) {
3716       {
3717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3718       };
3719     } catch (...) {
3720       {
3721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3722       };
3723     }
3724   }
3725
3726 }
3727
3728
3729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3730   char *arg1 = (char *) 0 ;
3731
3732   arg1 = (char *)jarg1;
3733   {
3734     try {
3735       Dali::Any::AssertAlways((char const *)arg1);
3736     } catch (std::out_of_range& e) {
3737       {
3738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3739       };
3740     } catch (std::exception& e) {
3741       {
3742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3743       };
3744     } catch (Dali::DaliException e) {
3745       {
3746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3747       };
3748     } catch (...) {
3749       {
3750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3751       };
3752     }
3753   }
3754
3755 }
3756
3757
3758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3759   void * jresult ;
3760   Dali::Any *arg1 = 0 ;
3761   Dali::Any *result = 0 ;
3762
3763   arg1 = (Dali::Any *)jarg1;
3764   if (!arg1) {
3765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3766     return 0;
3767   }
3768   {
3769     try {
3770       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3771     } catch (std::out_of_range& e) {
3772       {
3773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3774       };
3775     } catch (std::exception& e) {
3776       {
3777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3778       };
3779     } catch (Dali::DaliException e) {
3780       {
3781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3782       };
3783     } catch (...) {
3784       {
3785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3786       };
3787     }
3788   }
3789
3790   jresult = (void *)result;
3791   return jresult;
3792 }
3793
3794
3795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3796   void * jresult ;
3797   Dali::Any *arg1 = (Dali::Any *) 0 ;
3798   Dali::Any *arg2 = 0 ;
3799   Dali::Any *result = 0 ;
3800
3801   arg1 = (Dali::Any *)jarg1;
3802   arg2 = (Dali::Any *)jarg2;
3803   if (!arg2) {
3804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3805     return 0;
3806   }
3807   {
3808     try {
3809       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3810     } catch (std::out_of_range& e) {
3811       {
3812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3813       };
3814     } catch (std::exception& e) {
3815       {
3816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3817       };
3818     } catch (Dali::DaliException e) {
3819       {
3820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3821       };
3822     } catch (...) {
3823       {
3824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3825       };
3826     }
3827   }
3828
3829   jresult = (void *)result;
3830   return jresult;
3831 }
3832
3833
3834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3835   void * jresult ;
3836   Dali::Any *arg1 = (Dali::Any *) 0 ;
3837   std::type_info *result = 0 ;
3838
3839   arg1 = (Dali::Any *)jarg1;
3840   {
3841     try {
3842       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3843     } catch (std::out_of_range& e) {
3844       {
3845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3846       };
3847     } catch (std::exception& e) {
3848       {
3849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3850       };
3851     } catch (Dali::DaliException e) {
3852       {
3853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3854       };
3855     } catch (...) {
3856       {
3857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3858       };
3859     }
3860   }
3861
3862   jresult = (void *)result;
3863   return jresult;
3864 }
3865
3866
3867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3868   unsigned int jresult ;
3869   Dali::Any *arg1 = (Dali::Any *) 0 ;
3870   bool result;
3871
3872   arg1 = (Dali::Any *)jarg1;
3873   {
3874     try {
3875       result = (bool)((Dali::Any const *)arg1)->Empty();
3876     } catch (std::out_of_range& e) {
3877       {
3878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3879       };
3880     } catch (std::exception& e) {
3881       {
3882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3883       };
3884     } catch (Dali::DaliException e) {
3885       {
3886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3887       };
3888     } catch (...) {
3889       {
3890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3891       };
3892     }
3893   }
3894
3895   jresult = result;
3896   return jresult;
3897 }
3898
3899
3900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3901   void * jresult ;
3902   std::type_info *arg1 = 0 ;
3903   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3904   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3905   Dali::Any::AnyContainerBase *result = 0 ;
3906
3907   arg1 = (std::type_info *)jarg1;
3908   if (!arg1) {
3909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3910     return 0;
3911   }
3912   arg2 = (Dali::Any::CloneFunc)jarg2;
3913   arg3 = (Dali::Any::DeleteFunc)jarg3;
3914   {
3915     try {
3916       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3917     } catch (std::out_of_range& e) {
3918       {
3919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3920       };
3921     } catch (std::exception& e) {
3922       {
3923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3924       };
3925     } catch (Dali::DaliException e) {
3926       {
3927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3928       };
3929     } catch (...) {
3930       {
3931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3932       };
3933     }
3934   }
3935
3936   jresult = (void *)result;
3937   return jresult;
3938 }
3939
3940
3941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3942   void * jresult ;
3943   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3944   std::type_info *result = 0 ;
3945
3946   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3947   {
3948     try {
3949       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3950     } catch (std::out_of_range& e) {
3951       {
3952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3953       };
3954     } catch (std::exception& e) {
3955       {
3956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3957       };
3958     } catch (Dali::DaliException e) {
3959       {
3960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3961       };
3962     } catch (...) {
3963       {
3964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3965       };
3966     }
3967   }
3968
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3975   void * jresult ;
3976   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3977   ::std::type_info *result = 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3981   jresult = (void *)result;
3982   return jresult;
3983 }
3984
3985
3986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3987   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3988   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3989
3990   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3991   arg2 = (Dali::Any::CloneFunc)jarg2;
3992   if (arg1) (arg1)->mCloneFunc = arg2;
3993 }
3994
3995
3996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3997   void * jresult ;
3998   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3999   Dali::Any::CloneFunc result;
4000
4001   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4002   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
4003   jresult = (void *)result;
4004   return jresult;
4005 }
4006
4007
4008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4009   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4010   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   arg2 = (Dali::Any::DeleteFunc)jarg2;
4014   if (arg1) (arg1)->mDeleteFunc = arg2;
4015 }
4016
4017
4018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4019   void * jresult ;
4020   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4021   Dali::Any::DeleteFunc result;
4022
4023   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4024   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4025   jresult = (void *)result;
4026   return jresult;
4027 }
4028
4029
4030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4031   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4032
4033   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4034   {
4035     try {
4036       delete arg1;
4037     } catch (std::out_of_range& e) {
4038       {
4039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4040       };
4041     } catch (std::exception& e) {
4042       {
4043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4044       };
4045     } catch (Dali::DaliException e) {
4046       {
4047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4048       };
4049     } catch (...) {
4050       {
4051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4052       };
4053     }
4054   }
4055
4056 }
4057
4058
4059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4060   Dali::Any *arg1 = (Dali::Any *) 0 ;
4061   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4062
4063   arg1 = (Dali::Any *)jarg1;
4064   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4065   if (arg1) (arg1)->mContainer = arg2;
4066 }
4067
4068
4069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4070   void * jresult ;
4071   Dali::Any *arg1 = (Dali::Any *) 0 ;
4072   Dali::Any::AnyContainerBase *result = 0 ;
4073
4074   arg1 = (Dali::Any *)jarg1;
4075   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4076   jresult = (void *)result;
4077   return jresult;
4078 }
4079
4080
4081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4082   char *arg1 = (char *) 0 ;
4083   char *arg2 = (char *) 0 ;
4084
4085   arg1 = (char *)jarg1;
4086   arg2 = (char *)jarg2;
4087   {
4088     try {
4089       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4090     } catch (std::out_of_range& e) {
4091       {
4092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4093       };
4094     } catch (std::exception& e) {
4095       {
4096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4097       };
4098     } catch (Dali::DaliException e) {
4099       {
4100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4101       };
4102     } catch (...) {
4103       {
4104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4105       };
4106     }
4107   }
4108
4109 }
4110
4111
4112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4113   void * jresult ;
4114   char *arg1 = (char *) 0 ;
4115   char *arg2 = (char *) 0 ;
4116   Dali::DaliException *result = 0 ;
4117
4118   arg1 = (char *)jarg1;
4119   arg2 = (char *)jarg2;
4120   {
4121     try {
4122       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4123     } catch (std::out_of_range& e) {
4124       {
4125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4126       };
4127     } catch (std::exception& e) {
4128       {
4129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4130       };
4131     } catch (Dali::DaliException e) {
4132       {
4133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4134       };
4135     } catch (...) {
4136       {
4137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4138       };
4139     }
4140   }
4141
4142   jresult = (void *)result;
4143   return jresult;
4144 }
4145
4146
4147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4148   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4149   std::string arg2 = std::string(jarg2);
4150
4151   arg1 = (Dali::DaliException *)jarg1;
4152   {
4153     if (!arg2.empty()) {
4154       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4155     } else {
4156       arg1->location = 0;
4157     }
4158   }
4159 }
4160
4161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4162   char * jresult ;
4163   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4164   char *result = 0 ;
4165
4166   arg1 = (Dali::DaliException *)jarg1;
4167   result = (char *) ((arg1)->location);
4168   jresult = SWIG_csharp_string_callback((const char *)result);
4169   return jresult;
4170 }
4171
4172
4173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4174   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4175   std::string arg2 = std::string(jarg2);
4176
4177   arg1 = (Dali::DaliException *)jarg1;
4178   {
4179     if (!arg2.empty()) {
4180       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4181     } else {
4182       arg1->condition = 0;
4183     }
4184   }
4185 }
4186
4187
4188 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4189   char * jresult ;
4190   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4191   char *result = 0 ;
4192
4193   arg1 = (Dali::DaliException *)jarg1;
4194   result = (char *) ((arg1)->condition);
4195   jresult = SWIG_csharp_string_callback((const char *)result);
4196   return jresult;
4197 }
4198
4199
4200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4201   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4202
4203   arg1 = (Dali::DaliException *)jarg1;
4204   {
4205     try {
4206       delete arg1;
4207     } catch (std::out_of_range& e) {
4208       {
4209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4210       };
4211     } catch (std::exception& e) {
4212       {
4213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4214       };
4215     } catch (Dali::DaliException e) {
4216       {
4217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4218       };
4219     } catch (...) {
4220       {
4221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4222       };
4223     }
4224   }
4225
4226 }
4227
4228
4229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4230   void * jresult ;
4231   Dali::Vector2 *result = 0 ;
4232
4233   {
4234     try {
4235       result = (Dali::Vector2 *)new Dali::Vector2();
4236     } catch (std::out_of_range& e) {
4237       {
4238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4239       };
4240     } catch (std::exception& e) {
4241       {
4242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4243       };
4244     } catch (Dali::DaliException e) {
4245       {
4246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4247       };
4248     } catch (...) {
4249       {
4250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4251       };
4252     }
4253   }
4254
4255   jresult = (void *)result;
4256   return jresult;
4257 }
4258
4259
4260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4261   void * jresult ;
4262   float arg1 ;
4263   float arg2 ;
4264   Dali::Vector2 *result = 0 ;
4265
4266   arg1 = (float)jarg1;
4267   arg2 = (float)jarg2;
4268   {
4269     try {
4270       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4271     } catch (std::out_of_range& e) {
4272       {
4273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4274       };
4275     } catch (std::exception& e) {
4276       {
4277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4278       };
4279     } catch (Dali::DaliException e) {
4280       {
4281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4282       };
4283     } catch (...) {
4284       {
4285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4286       };
4287     }
4288   }
4289
4290   jresult = (void *)result;
4291   return jresult;
4292 }
4293
4294
4295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4296   void * jresult ;
4297   float *arg1 = (float *) 0 ;
4298   Dali::Vector2 *result = 0 ;
4299
4300   arg1 = jarg1;
4301   {
4302     try {
4303       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4304     } catch (std::out_of_range& e) {
4305       {
4306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4307       };
4308     } catch (std::exception& e) {
4309       {
4310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4311       };
4312     } catch (Dali::DaliException e) {
4313       {
4314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4315       };
4316     } catch (...) {
4317       {
4318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4319       };
4320     }
4321   }
4322
4323   jresult = (void *)result;
4324
4325
4326   return jresult;
4327 }
4328
4329
4330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4331   void * jresult ;
4332   Dali::Vector3 *arg1 = 0 ;
4333   Dali::Vector2 *result = 0 ;
4334
4335   arg1 = (Dali::Vector3 *)jarg1;
4336   if (!arg1) {
4337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4338     return 0;
4339   }
4340   {
4341     try {
4342       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4343     } catch (std::out_of_range& e) {
4344       {
4345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4346       };
4347     } catch (std::exception& e) {
4348       {
4349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4350       };
4351     } catch (Dali::DaliException e) {
4352       {
4353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4354       };
4355     } catch (...) {
4356       {
4357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4358       };
4359     }
4360   }
4361
4362   jresult = (void *)result;
4363   return jresult;
4364 }
4365
4366
4367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4368   void * jresult ;
4369   Dali::Vector4 *arg1 = 0 ;
4370   Dali::Vector2 *result = 0 ;
4371
4372   arg1 = (Dali::Vector4 *)jarg1;
4373   if (!arg1) {
4374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4375     return 0;
4376   }
4377   {
4378     try {
4379       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4380     } catch (std::out_of_range& e) {
4381       {
4382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4383       };
4384     } catch (std::exception& e) {
4385       {
4386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4387       };
4388     } catch (Dali::DaliException e) {
4389       {
4390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4391       };
4392     } catch (...) {
4393       {
4394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4395       };
4396     }
4397   }
4398
4399   jresult = (void *)result;
4400   return jresult;
4401 }
4402
4403
4404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4405   void * jresult ;
4406   Dali::Vector2 *result = 0 ;
4407
4408   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4409   jresult = (void *)result;
4410   return jresult;
4411 }
4412
4413
4414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4415   void * jresult ;
4416   Dali::Vector2 *result = 0 ;
4417
4418   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4419   jresult = (void *)result;
4420   return jresult;
4421 }
4422
4423
4424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4425   void * jresult ;
4426   Dali::Vector2 *result = 0 ;
4427
4428   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4429   jresult = (void *)result;
4430   return jresult;
4431 }
4432
4433
4434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4435   void * jresult ;
4436   Dali::Vector2 *result = 0 ;
4437
4438   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4445   void * jresult ;
4446   Dali::Vector2 *result = 0 ;
4447
4448   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4449   jresult = (void *)result;
4450   return jresult;
4451 }
4452
4453
4454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4455   void * jresult ;
4456   Dali::Vector2 *result = 0 ;
4457
4458   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4459   jresult = (void *)result;
4460   return jresult;
4461 }
4462
4463
4464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4465   void * jresult ;
4466   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4467   float *arg2 = (float *) 0 ;
4468   Dali::Vector2 *result = 0 ;
4469
4470   arg1 = (Dali::Vector2 *)jarg1;
4471   arg2 = jarg2;
4472   {
4473     try {
4474       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4475     } catch (std::out_of_range& e) {
4476       {
4477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4478       };
4479     } catch (std::exception& e) {
4480       {
4481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4482       };
4483     } catch (Dali::DaliException e) {
4484       {
4485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4486       };
4487     } catch (...) {
4488       {
4489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4490       };
4491     }
4492   }
4493
4494   jresult = (void *)result;
4495
4496
4497   return jresult;
4498 }
4499
4500
4501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4502   void * jresult ;
4503   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4504   Dali::Vector3 *arg2 = 0 ;
4505   Dali::Vector2 *result = 0 ;
4506
4507   arg1 = (Dali::Vector2 *)jarg1;
4508   arg2 = (Dali::Vector3 *)jarg2;
4509   if (!arg2) {
4510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4511     return 0;
4512   }
4513   {
4514     try {
4515       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4516     } catch (std::out_of_range& e) {
4517       {
4518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4519       };
4520     } catch (std::exception& e) {
4521       {
4522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (Dali::DaliException e) {
4525       {
4526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4527       };
4528     } catch (...) {
4529       {
4530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4531       };
4532     }
4533   }
4534
4535   jresult = (void *)result;
4536   return jresult;
4537 }
4538
4539
4540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4541   void * jresult ;
4542   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4543   Dali::Vector4 *arg2 = 0 ;
4544   Dali::Vector2 *result = 0 ;
4545
4546   arg1 = (Dali::Vector2 *)jarg1;
4547   arg2 = (Dali::Vector4 *)jarg2;
4548   if (!arg2) {
4549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4550     return 0;
4551   }
4552   {
4553     try {
4554       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4555     } catch (std::out_of_range& e) {
4556       {
4557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4558       };
4559     } catch (std::exception& e) {
4560       {
4561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4562       };
4563     } catch (Dali::DaliException e) {
4564       {
4565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4566       };
4567     } catch (...) {
4568       {
4569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4570       };
4571     }
4572   }
4573
4574   jresult = (void *)result;
4575   return jresult;
4576 }
4577
4578
4579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4580   void * jresult ;
4581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4582   Dali::Vector2 *arg2 = 0 ;
4583   Dali::Vector2 result;
4584
4585   arg1 = (Dali::Vector2 *)jarg1;
4586   arg2 = (Dali::Vector2 *)jarg2;
4587   if (!arg2) {
4588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4589     return 0;
4590   }
4591   {
4592     try {
4593       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4594     } catch (std::out_of_range& e) {
4595       {
4596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4597       };
4598     } catch (std::exception& e) {
4599       {
4600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (Dali::DaliException e) {
4603       {
4604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4605       };
4606     } catch (...) {
4607       {
4608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4609       };
4610     }
4611   }
4612
4613   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4614   return jresult;
4615 }
4616
4617
4618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4619   void * jresult ;
4620   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4621   Dali::Vector2 *arg2 = 0 ;
4622   Dali::Vector2 *result = 0 ;
4623
4624   arg1 = (Dali::Vector2 *)jarg1;
4625   arg2 = (Dali::Vector2 *)jarg2;
4626   if (!arg2) {
4627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4628     return 0;
4629   }
4630   {
4631     try {
4632       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4633     } catch (std::out_of_range& e) {
4634       {
4635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4636       };
4637     } catch (std::exception& e) {
4638       {
4639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4640       };
4641     } catch (Dali::DaliException e) {
4642       {
4643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4644       };
4645     } catch (...) {
4646       {
4647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4648       };
4649     }
4650   }
4651
4652   jresult = (void *)result;
4653   return jresult;
4654 }
4655
4656
4657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4658   void * jresult ;
4659   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4660   Dali::Vector2 *arg2 = 0 ;
4661   Dali::Vector2 result;
4662
4663   arg1 = (Dali::Vector2 *)jarg1;
4664   arg2 = (Dali::Vector2 *)jarg2;
4665   if (!arg2) {
4666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4667     return 0;
4668   }
4669   {
4670     try {
4671       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4672     } catch (std::out_of_range& e) {
4673       {
4674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4675       };
4676     } catch (std::exception& e) {
4677       {
4678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (Dali::DaliException e) {
4681       {
4682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4687       };
4688     }
4689   }
4690
4691   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4692   return jresult;
4693 }
4694
4695
4696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4697   void * jresult ;
4698   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4699   Dali::Vector2 *arg2 = 0 ;
4700   Dali::Vector2 *result = 0 ;
4701
4702   arg1 = (Dali::Vector2 *)jarg1;
4703   arg2 = (Dali::Vector2 *)jarg2;
4704   if (!arg2) {
4705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4706     return 0;
4707   }
4708   {
4709     try {
4710       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4711     } catch (std::out_of_range& e) {
4712       {
4713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4714       };
4715     } catch (std::exception& e) {
4716       {
4717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4718       };
4719     } catch (Dali::DaliException e) {
4720       {
4721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4722       };
4723     } catch (...) {
4724       {
4725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4726       };
4727     }
4728   }
4729
4730   jresult = (void *)result;
4731   return jresult;
4732 }
4733
4734
4735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4736   void * jresult ;
4737   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4738   Dali::Vector2 *arg2 = 0 ;
4739   Dali::Vector2 result;
4740
4741   arg1 = (Dali::Vector2 *)jarg1;
4742   arg2 = (Dali::Vector2 *)jarg2;
4743   if (!arg2) {
4744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4745     return 0;
4746   }
4747   {
4748     try {
4749       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4750     } catch (std::out_of_range& e) {
4751       {
4752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4753       };
4754     } catch (std::exception& e) {
4755       {
4756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4757       };
4758     } catch (Dali::DaliException e) {
4759       {
4760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4761       };
4762     } catch (...) {
4763       {
4764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4765       };
4766     }
4767   }
4768
4769   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4770   return jresult;
4771 }
4772
4773
4774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4775   void * jresult ;
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   float arg2 ;
4778   Dali::Vector2 result;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (float)jarg2;
4782   {
4783     try {
4784       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4785     } catch (std::out_of_range& e) {
4786       {
4787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4788       };
4789     } catch (std::exception& e) {
4790       {
4791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4792       };
4793     } catch (Dali::DaliException e) {
4794       {
4795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4796       };
4797     } catch (...) {
4798       {
4799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4800       };
4801     }
4802   }
4803
4804   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4805   return jresult;
4806 }
4807
4808
4809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4810   void * jresult ;
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   Dali::Vector2 *arg2 = 0 ;
4813   Dali::Vector2 *result = 0 ;
4814
4815   arg1 = (Dali::Vector2 *)jarg1;
4816   arg2 = (Dali::Vector2 *)jarg2;
4817   if (!arg2) {
4818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4819     return 0;
4820   }
4821   {
4822     try {
4823       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4824     } catch (std::out_of_range& e) {
4825       {
4826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4827       };
4828     } catch (std::exception& e) {
4829       {
4830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4831       };
4832     } catch (Dali::DaliException e) {
4833       {
4834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4835       };
4836     } catch (...) {
4837       {
4838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4839       };
4840     }
4841   }
4842
4843   jresult = (void *)result;
4844   return jresult;
4845 }
4846
4847
4848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4849   void * jresult ;
4850   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4851   float arg2 ;
4852   Dali::Vector2 *result = 0 ;
4853
4854   arg1 = (Dali::Vector2 *)jarg1;
4855   arg2 = (float)jarg2;
4856   {
4857     try {
4858       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4859     } catch (std::out_of_range& e) {
4860       {
4861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4862       };
4863     } catch (std::exception& e) {
4864       {
4865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4866       };
4867     } catch (Dali::DaliException e) {
4868       {
4869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4870       };
4871     } catch (...) {
4872       {
4873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4874       };
4875     }
4876   }
4877
4878   jresult = (void *)result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4884   void * jresult ;
4885   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4886   Dali::Vector2 *arg2 = 0 ;
4887   Dali::Vector2 result;
4888
4889   arg1 = (Dali::Vector2 *)jarg1;
4890   arg2 = (Dali::Vector2 *)jarg2;
4891   if (!arg2) {
4892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4893     return 0;
4894   }
4895   {
4896     try {
4897       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4898     } catch (std::out_of_range& e) {
4899       {
4900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4901       };
4902     } catch (std::exception& e) {
4903       {
4904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4905       };
4906     } catch (Dali::DaliException e) {
4907       {
4908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4909       };
4910     } catch (...) {
4911       {
4912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4913       };
4914     }
4915   }
4916
4917   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4918   return jresult;
4919 }
4920
4921
4922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4923   void * jresult ;
4924   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4925   float arg2 ;
4926   Dali::Vector2 result;
4927
4928   arg1 = (Dali::Vector2 *)jarg1;
4929   arg2 = (float)jarg2;
4930   {
4931     try {
4932       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4933     } catch (std::out_of_range& e) {
4934       {
4935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4936       };
4937     } catch (std::exception& e) {
4938       {
4939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4940       };
4941     } catch (Dali::DaliException e) {
4942       {
4943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4944       };
4945     } catch (...) {
4946       {
4947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4948       };
4949     }
4950   }
4951
4952   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4953   return jresult;
4954 }
4955
4956
4957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4958   void * jresult ;
4959   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4960   Dali::Vector2 *arg2 = 0 ;
4961   Dali::Vector2 *result = 0 ;
4962
4963   arg1 = (Dali::Vector2 *)jarg1;
4964   arg2 = (Dali::Vector2 *)jarg2;
4965   if (!arg2) {
4966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4967     return 0;
4968   }
4969   {
4970     try {
4971       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4972     } catch (std::out_of_range& e) {
4973       {
4974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4975       };
4976     } catch (std::exception& e) {
4977       {
4978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4979       };
4980     } catch (Dali::DaliException e) {
4981       {
4982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4983       };
4984     } catch (...) {
4985       {
4986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4987       };
4988     }
4989   }
4990
4991   jresult = (void *)result;
4992   return jresult;
4993 }
4994
4995
4996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4997   void * jresult ;
4998   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4999   float arg2 ;
5000   Dali::Vector2 *result = 0 ;
5001
5002   arg1 = (Dali::Vector2 *)jarg1;
5003   arg2 = (float)jarg2;
5004   {
5005     try {
5006       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5007     } catch (std::out_of_range& e) {
5008       {
5009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5010       };
5011     } catch (std::exception& e) {
5012       {
5013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (Dali::DaliException e) {
5016       {
5017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025
5026   jresult = (void *)result;
5027   return jresult;
5028 }
5029
5030
5031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5032   void * jresult ;
5033   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5034   Dali::Vector2 result;
5035
5036   arg1 = (Dali::Vector2 *)jarg1;
5037   {
5038     try {
5039       result = ((Dali::Vector2 const *)arg1)->operator -();
5040     } catch (std::out_of_range& e) {
5041       {
5042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5043       };
5044     } catch (std::exception& e) {
5045       {
5046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5047       };
5048     } catch (Dali::DaliException e) {
5049       {
5050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5051       };
5052     } catch (...) {
5053       {
5054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5055       };
5056     }
5057   }
5058
5059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5060   return jresult;
5061 }
5062
5063
5064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5065   unsigned int jresult ;
5066   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5067   Dali::Vector2 *arg2 = 0 ;
5068   bool result;
5069
5070   arg1 = (Dali::Vector2 *)jarg1;
5071   arg2 = (Dali::Vector2 *)jarg2;
5072   if (!arg2) {
5073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5074     return 0;
5075   }
5076   {
5077     try {
5078       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5079     } catch (std::out_of_range& e) {
5080       {
5081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5082       };
5083     } catch (std::exception& e) {
5084       {
5085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5086       };
5087     } catch (Dali::DaliException e) {
5088       {
5089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5090       };
5091     } catch (...) {
5092       {
5093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5094       };
5095     }
5096   }
5097
5098   jresult = result;
5099   return jresult;
5100 }
5101
5102
5103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5104   unsigned int jresult ;
5105   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5106   Dali::Vector2 *arg2 = 0 ;
5107   bool result;
5108
5109   arg1 = (Dali::Vector2 *)jarg1;
5110   arg2 = (Dali::Vector2 *)jarg2;
5111   if (!arg2) {
5112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5113     return 0;
5114   }
5115   {
5116     try {
5117       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5118     } catch (std::out_of_range& e) {
5119       {
5120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5121       };
5122     } catch (std::exception& e) {
5123       {
5124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5125       };
5126     } catch (Dali::DaliException e) {
5127       {
5128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5129       };
5130     } catch (...) {
5131       {
5132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5133       };
5134     }
5135   }
5136
5137   jresult = result;
5138   return jresult;
5139 }
5140
5141
5142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5143   float jresult ;
5144   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5145   unsigned int arg2 ;
5146   float *result = 0 ;
5147
5148   arg1 = (Dali::Vector2 *)jarg1;
5149   arg2 = (unsigned int)jarg2;
5150   {
5151     try {
5152       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5153     } catch (std::out_of_range& e) {
5154       {
5155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5156       };
5157     } catch (std::exception& e) {
5158       {
5159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5160       };
5161     } catch (Dali::DaliException e) {
5162       {
5163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5164       };
5165     } catch (...) {
5166       {
5167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5168       };
5169     }
5170   }
5171
5172   jresult = *result;
5173   return jresult;
5174 }
5175
5176
5177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5178   float jresult ;
5179   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5180   float result;
5181
5182   arg1 = (Dali::Vector2 *)jarg1;
5183   {
5184     try {
5185       result = (float)((Dali::Vector2 const *)arg1)->Length();
5186     } catch (std::out_of_range& e) {
5187       {
5188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5189       };
5190     } catch (std::exception& e) {
5191       {
5192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5193       };
5194     } catch (Dali::DaliException e) {
5195       {
5196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5197       };
5198     } catch (...) {
5199       {
5200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5201       };
5202     }
5203   }
5204
5205   jresult = result;
5206   return jresult;
5207 }
5208
5209
5210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5211   float jresult ;
5212   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5213   float result;
5214
5215   arg1 = (Dali::Vector2 *)jarg1;
5216   {
5217     try {
5218       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5219     } catch (std::out_of_range& e) {
5220       {
5221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (std::exception& e) {
5224       {
5225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5226       };
5227     } catch (Dali::DaliException e) {
5228       {
5229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5230       };
5231     } catch (...) {
5232       {
5233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5234       };
5235     }
5236   }
5237
5238   jresult = result;
5239   return jresult;
5240 }
5241
5242
5243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5244   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5245
5246   arg1 = (Dali::Vector2 *)jarg1;
5247   {
5248     try {
5249       (arg1)->Normalize();
5250     } catch (std::out_of_range& e) {
5251       {
5252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5253       };
5254     } catch (std::exception& e) {
5255       {
5256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5257       };
5258     } catch (Dali::DaliException e) {
5259       {
5260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5261       };
5262     } catch (...) {
5263       {
5264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5265       };
5266     }
5267   }
5268
5269 }
5270
5271
5272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5273   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5274   Dali::Vector2 *arg2 = 0 ;
5275   Dali::Vector2 *arg3 = 0 ;
5276
5277   arg1 = (Dali::Vector2 *)jarg1;
5278   arg2 = (Dali::Vector2 *)jarg2;
5279   if (!arg2) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   arg3 = (Dali::Vector2 *)jarg3;
5284   if (!arg3) {
5285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5286     return ;
5287   }
5288   {
5289     try {
5290       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5291     } catch (std::out_of_range& e) {
5292       {
5293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5294       };
5295     } catch (std::exception& e) {
5296       {
5297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5298       };
5299     } catch (Dali::DaliException e) {
5300       {
5301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5302       };
5303     } catch (...) {
5304       {
5305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5306       };
5307     }
5308   }
5309
5310 }
5311
5312
5313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5314   void * jresult ;
5315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5316   float *result = 0 ;
5317
5318   arg1 = (Dali::Vector2 *)jarg1;
5319   {
5320     try {
5321       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5322     } catch (std::out_of_range& e) {
5323       {
5324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5325       };
5326     } catch (std::exception& e) {
5327       {
5328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5329       };
5330     } catch (Dali::DaliException e) {
5331       {
5332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5333       };
5334     } catch (...) {
5335       {
5336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5337       };
5338     }
5339   }
5340
5341   jresult = (void *)result;
5342   return jresult;
5343 }
5344
5345
5346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5347   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5348   float arg2 ;
5349
5350   arg1 = (Dali::Vector2 *)jarg1;
5351   arg2 = (float)jarg2;
5352   if (arg1) (arg1)->x = arg2;
5353 }
5354
5355
5356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5357   float jresult ;
5358   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5359   float result;
5360
5361   arg1 = (Dali::Vector2 *)jarg1;
5362   result = (float) ((arg1)->x);
5363   jresult = result;
5364   return jresult;
5365 }
5366
5367
5368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5369   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5370   float arg2 ;
5371
5372   arg1 = (Dali::Vector2 *)jarg1;
5373   arg2 = (float)jarg2;
5374   if (arg1) (arg1)->width = arg2;
5375 }
5376
5377
5378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5379   float jresult ;
5380   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5381   float result;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   result = (float) ((arg1)->width);
5385   jresult = result;
5386   return jresult;
5387 }
5388
5389
5390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5391   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5392   float arg2 ;
5393
5394   arg1 = (Dali::Vector2 *)jarg1;
5395   arg2 = (float)jarg2;
5396   if (arg1) (arg1)->y = arg2;
5397 }
5398
5399
5400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5401   float jresult ;
5402   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5403   float result;
5404
5405   arg1 = (Dali::Vector2 *)jarg1;
5406   result = (float) ((arg1)->y);
5407   jresult = result;
5408   return jresult;
5409 }
5410
5411
5412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5414   float arg2 ;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   arg2 = (float)jarg2;
5418   if (arg1) (arg1)->height = arg2;
5419 }
5420
5421
5422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5423   float jresult ;
5424   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5425   float result;
5426
5427   arg1 = (Dali::Vector2 *)jarg1;
5428   result = (float) ((arg1)->height);
5429   jresult = result;
5430   return jresult;
5431 }
5432
5433
5434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5435   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5436
5437   arg1 = (Dali::Vector2 *)jarg1;
5438   {
5439     try {
5440       delete arg1;
5441     } catch (std::out_of_range& e) {
5442       {
5443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5444       };
5445     } catch (std::exception& e) {
5446       {
5447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5448       };
5449     } catch (Dali::DaliException e) {
5450       {
5451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5452       };
5453     } catch (...) {
5454       {
5455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5456       };
5457     }
5458   }
5459
5460 }
5461
5462
5463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5464   void * jresult ;
5465   Dali::Vector2 *arg1 = 0 ;
5466   Dali::Vector2 *arg2 = 0 ;
5467   Dali::Vector2 result;
5468
5469   arg1 = (Dali::Vector2 *)jarg1;
5470   if (!arg1) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   arg2 = (Dali::Vector2 *)jarg2;
5475   if (!arg2) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5477     return 0;
5478   }
5479   {
5480     try {
5481       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5482     } catch (std::out_of_range& e) {
5483       {
5484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (std::exception& e) {
5487       {
5488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (Dali::DaliException e) {
5491       {
5492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5493       };
5494     } catch (...) {
5495       {
5496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5497       };
5498     }
5499   }
5500
5501   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5502   return jresult;
5503 }
5504
5505
5506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5507   void * jresult ;
5508   Dali::Vector2 *arg1 = 0 ;
5509   Dali::Vector2 *arg2 = 0 ;
5510   Dali::Vector2 result;
5511
5512   arg1 = (Dali::Vector2 *)jarg1;
5513   if (!arg1) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   arg2 = (Dali::Vector2 *)jarg2;
5518   if (!arg2) {
5519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5520     return 0;
5521   }
5522   {
5523     try {
5524       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5525     } catch (std::out_of_range& e) {
5526       {
5527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5528       };
5529     } catch (std::exception& e) {
5530       {
5531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5532       };
5533     } catch (Dali::DaliException e) {
5534       {
5535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5536       };
5537     } catch (...) {
5538       {
5539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5540       };
5541     }
5542   }
5543
5544   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5545   return jresult;
5546 }
5547
5548
5549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5550   void * jresult ;
5551   Dali::Vector2 *arg1 = 0 ;
5552   float *arg2 = 0 ;
5553   float *arg3 = 0 ;
5554   float temp2 ;
5555   float temp3 ;
5556   Dali::Vector2 result;
5557
5558   arg1 = (Dali::Vector2 *)jarg1;
5559   if (!arg1) {
5560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5561     return 0;
5562   }
5563   temp2 = (float)jarg2;
5564   arg2 = &temp2;
5565   temp3 = (float)jarg3;
5566   arg3 = &temp3;
5567   {
5568     try {
5569       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5570     } catch (std::out_of_range& e) {
5571       {
5572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5573       };
5574     } catch (std::exception& e) {
5575       {
5576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5577       };
5578     } catch (Dali::DaliException e) {
5579       {
5580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5581       };
5582     } catch (...) {
5583       {
5584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5585       };
5586     }
5587   }
5588
5589   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5590   return jresult;
5591 }
5592
5593
5594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5595   void * jresult ;
5596   Dali::Vector3 *result = 0 ;
5597
5598   {
5599     try {
5600       result = (Dali::Vector3 *)new Dali::Vector3();
5601     } catch (std::out_of_range& e) {
5602       {
5603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5604       };
5605     } catch (std::exception& e) {
5606       {
5607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5608       };
5609     } catch (Dali::DaliException e) {
5610       {
5611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5612       };
5613     } catch (...) {
5614       {
5615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5616       };
5617     }
5618   }
5619
5620   jresult = (void *)result;
5621   return jresult;
5622 }
5623
5624
5625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5626   void * jresult ;
5627   float arg1 ;
5628   float arg2 ;
5629   float arg3 ;
5630   Dali::Vector3 *result = 0 ;
5631
5632   arg1 = (float)jarg1;
5633   arg2 = (float)jarg2;
5634   arg3 = (float)jarg3;
5635   {
5636     try {
5637       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5638     } catch (std::out_of_range& e) {
5639       {
5640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5641       };
5642     } catch (std::exception& e) {
5643       {
5644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5645       };
5646     } catch (Dali::DaliException e) {
5647       {
5648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5649       };
5650     } catch (...) {
5651       {
5652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5653       };
5654     }
5655   }
5656
5657   jresult = (void *)result;
5658   return jresult;
5659 }
5660
5661
5662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5663   void * jresult ;
5664   float *arg1 = (float *) 0 ;
5665   Dali::Vector3 *result = 0 ;
5666
5667   arg1 = jarg1;
5668   {
5669     try {
5670       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5671     } catch (std::out_of_range& e) {
5672       {
5673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5674       };
5675     } catch (std::exception& e) {
5676       {
5677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5678       };
5679     } catch (Dali::DaliException e) {
5680       {
5681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5682       };
5683     } catch (...) {
5684       {
5685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5686       };
5687     }
5688   }
5689
5690   jresult = (void *)result;
5691
5692
5693   return jresult;
5694 }
5695
5696
5697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5698   void * jresult ;
5699   Dali::Vector2 *arg1 = 0 ;
5700   Dali::Vector3 *result = 0 ;
5701
5702   arg1 = (Dali::Vector2 *)jarg1;
5703   if (!arg1) {
5704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5705     return 0;
5706   }
5707   {
5708     try {
5709       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5710     } catch (std::out_of_range& e) {
5711       {
5712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5713       };
5714     } catch (std::exception& e) {
5715       {
5716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5717       };
5718     } catch (Dali::DaliException e) {
5719       {
5720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5721       };
5722     } catch (...) {
5723       {
5724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5725       };
5726     }
5727   }
5728
5729   jresult = (void *)result;
5730   return jresult;
5731 }
5732
5733
5734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5735   void * jresult ;
5736   Dali::Vector4 *arg1 = 0 ;
5737   Dali::Vector3 *result = 0 ;
5738
5739   arg1 = (Dali::Vector4 *)jarg1;
5740   if (!arg1) {
5741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5742     return 0;
5743   }
5744   {
5745     try {
5746       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5747     } catch (std::out_of_range& e) {
5748       {
5749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5750       };
5751     } catch (std::exception& e) {
5752       {
5753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5754       };
5755     } catch (Dali::DaliException e) {
5756       {
5757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5758       };
5759     } catch (...) {
5760       {
5761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5762       };
5763     }
5764   }
5765
5766   jresult = (void *)result;
5767   return jresult;
5768 }
5769
5770
5771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5772   void * jresult ;
5773   Dali::Vector3 *result = 0 ;
5774
5775   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5776   jresult = (void *)result;
5777   return jresult;
5778 }
5779
5780
5781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5782   void * jresult ;
5783   Dali::Vector3 *result = 0 ;
5784
5785   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5786   jresult = (void *)result;
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5792   void * jresult ;
5793   Dali::Vector3 *result = 0 ;
5794
5795   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5796   jresult = (void *)result;
5797   return jresult;
5798 }
5799
5800
5801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5802   void * jresult ;
5803   Dali::Vector3 *result = 0 ;
5804
5805   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5806   jresult = (void *)result;
5807   return jresult;
5808 }
5809
5810
5811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5812   void * jresult ;
5813   Dali::Vector3 *result = 0 ;
5814
5815   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5822   void * jresult ;
5823   Dali::Vector3 *result = 0 ;
5824
5825   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5826   jresult = (void *)result;
5827   return jresult;
5828 }
5829
5830
5831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5832   void * jresult ;
5833   Dali::Vector3 *result = 0 ;
5834
5835   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5836   jresult = (void *)result;
5837   return jresult;
5838 }
5839
5840
5841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5842   void * jresult ;
5843   Dali::Vector3 *result = 0 ;
5844
5845   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5846   jresult = (void *)result;
5847   return jresult;
5848 }
5849
5850
5851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5852   void * jresult ;
5853   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5854   float *arg2 = (float *) 0 ;
5855   Dali::Vector3 *result = 0 ;
5856
5857   arg1 = (Dali::Vector3 *)jarg1;
5858   arg2 = jarg2;
5859   {
5860     try {
5861       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5862     } catch (std::out_of_range& e) {
5863       {
5864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5865       };
5866     } catch (std::exception& e) {
5867       {
5868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5869       };
5870     } catch (Dali::DaliException e) {
5871       {
5872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5873       };
5874     } catch (...) {
5875       {
5876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5877       };
5878     }
5879   }
5880
5881   jresult = (void *)result;
5882
5883
5884   return jresult;
5885 }
5886
5887
5888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5889   void * jresult ;
5890   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5891   Dali::Vector2 *arg2 = 0 ;
5892   Dali::Vector3 *result = 0 ;
5893
5894   arg1 = (Dali::Vector3 *)jarg1;
5895   arg2 = (Dali::Vector2 *)jarg2;
5896   if (!arg2) {
5897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5898     return 0;
5899   }
5900   {
5901     try {
5902       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5903     } catch (std::out_of_range& e) {
5904       {
5905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5906       };
5907     } catch (std::exception& e) {
5908       {
5909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5910       };
5911     } catch (Dali::DaliException e) {
5912       {
5913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5914       };
5915     } catch (...) {
5916       {
5917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5918       };
5919     }
5920   }
5921
5922   jresult = (void *)result;
5923   return jresult;
5924 }
5925
5926
5927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5928   void * jresult ;
5929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5930   Dali::Vector4 *arg2 = 0 ;
5931   Dali::Vector3 *result = 0 ;
5932
5933   arg1 = (Dali::Vector3 *)jarg1;
5934   arg2 = (Dali::Vector4 *)jarg2;
5935   if (!arg2) {
5936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5937     return 0;
5938   }
5939   {
5940     try {
5941       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5942     } catch (std::out_of_range& e) {
5943       {
5944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5945       };
5946     } catch (std::exception& e) {
5947       {
5948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5949       };
5950     } catch (Dali::DaliException e) {
5951       {
5952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5953       };
5954     } catch (...) {
5955       {
5956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5957       };
5958     }
5959   }
5960
5961   jresult = (void *)result;
5962   return jresult;
5963 }
5964
5965
5966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5967   void * jresult ;
5968   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5969   Dali::Vector3 *arg2 = 0 ;
5970   Dali::Vector3 result;
5971
5972   arg1 = (Dali::Vector3 *)jarg1;
5973   arg2 = (Dali::Vector3 *)jarg2;
5974   if (!arg2) {
5975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5976     return 0;
5977   }
5978   {
5979     try {
5980       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5981     } catch (std::out_of_range& e) {
5982       {
5983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5984       };
5985     } catch (std::exception& e) {
5986       {
5987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5988       };
5989     } catch (Dali::DaliException e) {
5990       {
5991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5992       };
5993     } catch (...) {
5994       {
5995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5996       };
5997     }
5998   }
5999
6000   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6001   return jresult;
6002 }
6003
6004
6005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6006   void * jresult ;
6007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6008   Dali::Vector3 *arg2 = 0 ;
6009   Dali::Vector3 *result = 0 ;
6010
6011   arg1 = (Dali::Vector3 *)jarg1;
6012   arg2 = (Dali::Vector3 *)jarg2;
6013   if (!arg2) {
6014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6015     return 0;
6016   }
6017   {
6018     try {
6019       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (Dali::DaliException e) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6031       };
6032     } catch (...) {
6033       {
6034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6035       };
6036     }
6037   }
6038
6039   jresult = (void *)result;
6040   return jresult;
6041 }
6042
6043
6044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6045   void * jresult ;
6046   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6047   Dali::Vector3 *arg2 = 0 ;
6048   Dali::Vector3 result;
6049
6050   arg1 = (Dali::Vector3 *)jarg1;
6051   arg2 = (Dali::Vector3 *)jarg2;
6052   if (!arg2) {
6053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6054     return 0;
6055   }
6056   {
6057     try {
6058       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6059     } catch (std::out_of_range& e) {
6060       {
6061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6062       };
6063     } catch (std::exception& e) {
6064       {
6065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6066       };
6067     } catch (Dali::DaliException e) {
6068       {
6069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6070       };
6071     } catch (...) {
6072       {
6073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6074       };
6075     }
6076   }
6077
6078   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6079   return jresult;
6080 }
6081
6082
6083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6084   void * jresult ;
6085   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6086   Dali::Vector3 *arg2 = 0 ;
6087   Dali::Vector3 *result = 0 ;
6088
6089   arg1 = (Dali::Vector3 *)jarg1;
6090   arg2 = (Dali::Vector3 *)jarg2;
6091   if (!arg2) {
6092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6093     return 0;
6094   }
6095   {
6096     try {
6097       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6098     } catch (std::out_of_range& e) {
6099       {
6100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6101       };
6102     } catch (std::exception& e) {
6103       {
6104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6105       };
6106     } catch (Dali::DaliException e) {
6107       {
6108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6109       };
6110     } catch (...) {
6111       {
6112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6113       };
6114     }
6115   }
6116
6117   jresult = (void *)result;
6118   return jresult;
6119 }
6120
6121
6122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6123   void * jresult ;
6124   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6125   Dali::Vector3 *arg2 = 0 ;
6126   Dali::Vector3 result;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (Dali::Vector3 *)jarg2;
6130   if (!arg2) {
6131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6132     return 0;
6133   }
6134   {
6135     try {
6136       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6137     } catch (std::out_of_range& e) {
6138       {
6139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6140       };
6141     } catch (std::exception& e) {
6142       {
6143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6144       };
6145     } catch (Dali::DaliException e) {
6146       {
6147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6148       };
6149     } catch (...) {
6150       {
6151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6152       };
6153     }
6154   }
6155
6156   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6157   return jresult;
6158 }
6159
6160
6161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6162   void * jresult ;
6163   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6164   float arg2 ;
6165   Dali::Vector3 result;
6166
6167   arg1 = (Dali::Vector3 *)jarg1;
6168   arg2 = (float)jarg2;
6169   {
6170     try {
6171       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6172     } catch (std::out_of_range& e) {
6173       {
6174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (std::exception& e) {
6177       {
6178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (Dali::DaliException e) {
6181       {
6182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6183       };
6184     } catch (...) {
6185       {
6186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6187       };
6188     }
6189   }
6190
6191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6192   return jresult;
6193 }
6194
6195
6196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6197   void * jresult ;
6198   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6199   Dali::Vector3 *arg2 = 0 ;
6200   Dali::Vector3 *result = 0 ;
6201
6202   arg1 = (Dali::Vector3 *)jarg1;
6203   arg2 = (Dali::Vector3 *)jarg2;
6204   if (!arg2) {
6205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6206     return 0;
6207   }
6208   {
6209     try {
6210       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6211     } catch (std::out_of_range& e) {
6212       {
6213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6214       };
6215     } catch (std::exception& e) {
6216       {
6217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6218       };
6219     } catch (Dali::DaliException e) {
6220       {
6221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6222       };
6223     } catch (...) {
6224       {
6225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6226       };
6227     }
6228   }
6229
6230   jresult = (void *)result;
6231   return jresult;
6232 }
6233
6234
6235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6236   void * jresult ;
6237   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6238   float arg2 ;
6239   Dali::Vector3 *result = 0 ;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   arg2 = (float)jarg2;
6243   {
6244     try {
6245       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6246     } catch (std::out_of_range& e) {
6247       {
6248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6249       };
6250     } catch (std::exception& e) {
6251       {
6252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6253       };
6254     } catch (Dali::DaliException e) {
6255       {
6256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6257       };
6258     } catch (...) {
6259       {
6260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6261       };
6262     }
6263   }
6264
6265   jresult = (void *)result;
6266   return jresult;
6267 }
6268
6269
6270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6271   void * jresult ;
6272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6273   Dali::Quaternion *arg2 = 0 ;
6274   Dali::Vector3 *result = 0 ;
6275
6276   arg1 = (Dali::Vector3 *)jarg1;
6277   arg2 = (Dali::Quaternion *)jarg2;
6278   if (!arg2) {
6279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6280     return 0;
6281   }
6282   {
6283     try {
6284       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6285     } catch (std::out_of_range& e) {
6286       {
6287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6288       };
6289     } catch (std::exception& e) {
6290       {
6291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6292       };
6293     } catch (Dali::DaliException e) {
6294       {
6295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6296       };
6297     } catch (...) {
6298       {
6299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6300       };
6301     }
6302   }
6303
6304   jresult = (void *)result;
6305   return jresult;
6306 }
6307
6308
6309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6310   void * jresult ;
6311   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6312   Dali::Vector3 *arg2 = 0 ;
6313   Dali::Vector3 result;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   arg2 = (Dali::Vector3 *)jarg2;
6317   if (!arg2) {
6318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6319     return 0;
6320   }
6321   {
6322     try {
6323       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6324     } catch (std::out_of_range& e) {
6325       {
6326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6327       };
6328     } catch (std::exception& e) {
6329       {
6330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6331       };
6332     } catch (Dali::DaliException e) {
6333       {
6334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6335       };
6336     } catch (...) {
6337       {
6338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6339       };
6340     }
6341   }
6342
6343   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6344   return jresult;
6345 }
6346
6347
6348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6349   void * jresult ;
6350   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6351   float arg2 ;
6352   Dali::Vector3 result;
6353
6354   arg1 = (Dali::Vector3 *)jarg1;
6355   arg2 = (float)jarg2;
6356   {
6357     try {
6358       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6359     } catch (std::out_of_range& e) {
6360       {
6361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6362       };
6363     } catch (std::exception& e) {
6364       {
6365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6366       };
6367     } catch (Dali::DaliException e) {
6368       {
6369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6370       };
6371     } catch (...) {
6372       {
6373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6374       };
6375     }
6376   }
6377
6378   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6379   return jresult;
6380 }
6381
6382
6383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6384   void * jresult ;
6385   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6386   Dali::Vector3 *arg2 = 0 ;
6387   Dali::Vector3 *result = 0 ;
6388
6389   arg1 = (Dali::Vector3 *)jarg1;
6390   arg2 = (Dali::Vector3 *)jarg2;
6391   if (!arg2) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6393     return 0;
6394   }
6395   {
6396     try {
6397       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6398     } catch (std::out_of_range& e) {
6399       {
6400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6401       };
6402     } catch (std::exception& e) {
6403       {
6404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6405       };
6406     } catch (Dali::DaliException e) {
6407       {
6408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6409       };
6410     } catch (...) {
6411       {
6412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6413       };
6414     }
6415   }
6416
6417   jresult = (void *)result;
6418   return jresult;
6419 }
6420
6421
6422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6423   void * jresult ;
6424   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6425   float arg2 ;
6426   Dali::Vector3 *result = 0 ;
6427
6428   arg1 = (Dali::Vector3 *)jarg1;
6429   arg2 = (float)jarg2;
6430   {
6431     try {
6432       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6433     } catch (std::out_of_range& e) {
6434       {
6435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6436       };
6437     } catch (std::exception& e) {
6438       {
6439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6440       };
6441     } catch (Dali::DaliException e) {
6442       {
6443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6444       };
6445     } catch (...) {
6446       {
6447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6448       };
6449     }
6450   }
6451
6452   jresult = (void *)result;
6453   return jresult;
6454 }
6455
6456
6457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6458   void * jresult ;
6459   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6460   Dali::Vector3 result;
6461
6462   arg1 = (Dali::Vector3 *)jarg1;
6463   {
6464     try {
6465       result = ((Dali::Vector3 const *)arg1)->operator -();
6466     } catch (std::out_of_range& e) {
6467       {
6468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6469       };
6470     } catch (std::exception& e) {
6471       {
6472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6473       };
6474     } catch (Dali::DaliException e) {
6475       {
6476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6477       };
6478     } catch (...) {
6479       {
6480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6481       };
6482     }
6483   }
6484
6485   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6486   return jresult;
6487 }
6488
6489
6490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6491   unsigned int jresult ;
6492   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6493   Dali::Vector3 *arg2 = 0 ;
6494   bool result;
6495
6496   arg1 = (Dali::Vector3 *)jarg1;
6497   arg2 = (Dali::Vector3 *)jarg2;
6498   if (!arg2) {
6499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6500     return 0;
6501   }
6502   {
6503     try {
6504       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6505     } catch (std::out_of_range& e) {
6506       {
6507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6508       };
6509     } catch (std::exception& e) {
6510       {
6511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6512       };
6513     } catch (Dali::DaliException e) {
6514       {
6515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6516       };
6517     } catch (...) {
6518       {
6519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6520       };
6521     }
6522   }
6523
6524   jresult = result;
6525   return jresult;
6526 }
6527
6528
6529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6530   unsigned int jresult ;
6531   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6532   Dali::Vector3 *arg2 = 0 ;
6533   bool result;
6534
6535   arg1 = (Dali::Vector3 *)jarg1;
6536   arg2 = (Dali::Vector3 *)jarg2;
6537   if (!arg2) {
6538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6539     return 0;
6540   }
6541   {
6542     try {
6543       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6544     } catch (std::out_of_range& e) {
6545       {
6546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6547       };
6548     } catch (std::exception& e) {
6549       {
6550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6551       };
6552     } catch (Dali::DaliException e) {
6553       {
6554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6555       };
6556     } catch (...) {
6557       {
6558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6559       };
6560     }
6561   }
6562
6563   jresult = result;
6564   return jresult;
6565 }
6566
6567
6568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6569   float jresult ;
6570   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6571   unsigned int arg2 ;
6572   float *result = 0 ;
6573
6574   arg1 = (Dali::Vector3 *)jarg1;
6575   arg2 = (unsigned int)jarg2;
6576   {
6577     try {
6578       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6579     } catch (std::out_of_range& e) {
6580       {
6581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6582       };
6583     } catch (std::exception& e) {
6584       {
6585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6586       };
6587     } catch (Dali::DaliException e) {
6588       {
6589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6590       };
6591     } catch (...) {
6592       {
6593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6594       };
6595     }
6596   }
6597
6598   jresult = *result;
6599   return jresult;
6600 }
6601
6602
6603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6604   float jresult ;
6605   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6606   Dali::Vector3 *arg2 = 0 ;
6607   float result;
6608
6609   arg1 = (Dali::Vector3 *)jarg1;
6610   arg2 = (Dali::Vector3 *)jarg2;
6611   if (!arg2) {
6612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6613     return 0;
6614   }
6615   {
6616     try {
6617       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6618     } catch (std::out_of_range& e) {
6619       {
6620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6621       };
6622     } catch (std::exception& e) {
6623       {
6624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (Dali::DaliException e) {
6627       {
6628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6629       };
6630     } catch (...) {
6631       {
6632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6633       };
6634     }
6635   }
6636
6637   jresult = result;
6638   return jresult;
6639 }
6640
6641
6642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6643   void * jresult ;
6644   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6645   Dali::Vector3 *arg2 = 0 ;
6646   Dali::Vector3 result;
6647
6648   arg1 = (Dali::Vector3 *)jarg1;
6649   arg2 = (Dali::Vector3 *)jarg2;
6650   if (!arg2) {
6651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6652     return 0;
6653   }
6654   {
6655     try {
6656       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6657     } catch (std::out_of_range& e) {
6658       {
6659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6660       };
6661     } catch (std::exception& e) {
6662       {
6663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6664       };
6665     } catch (Dali::DaliException e) {
6666       {
6667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6668       };
6669     } catch (...) {
6670       {
6671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6672       };
6673     }
6674   }
6675
6676   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6677   return jresult;
6678 }
6679
6680
6681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6682   float jresult ;
6683   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6684   float result;
6685
6686   arg1 = (Dali::Vector3 *)jarg1;
6687   {
6688     try {
6689       result = (float)((Dali::Vector3 const *)arg1)->Length();
6690     } catch (std::out_of_range& e) {
6691       {
6692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6693       };
6694     } catch (std::exception& e) {
6695       {
6696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6697       };
6698     } catch (Dali::DaliException e) {
6699       {
6700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6701       };
6702     } catch (...) {
6703       {
6704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6705       };
6706     }
6707   }
6708
6709   jresult = result;
6710   return jresult;
6711 }
6712
6713
6714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6715   float jresult ;
6716   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6717   float result;
6718
6719   arg1 = (Dali::Vector3 *)jarg1;
6720   {
6721     try {
6722       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6723     } catch (std::out_of_range& e) {
6724       {
6725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6726       };
6727     } catch (std::exception& e) {
6728       {
6729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6730       };
6731     } catch (Dali::DaliException e) {
6732       {
6733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6734       };
6735     } catch (...) {
6736       {
6737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6738       };
6739     }
6740   }
6741
6742   jresult = result;
6743   return jresult;
6744 }
6745
6746
6747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6748   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6749
6750   arg1 = (Dali::Vector3 *)jarg1;
6751   {
6752     try {
6753       (arg1)->Normalize();
6754     } catch (std::out_of_range& e) {
6755       {
6756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6757       };
6758     } catch (std::exception& e) {
6759       {
6760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6761       };
6762     } catch (Dali::DaliException e) {
6763       {
6764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6765       };
6766     } catch (...) {
6767       {
6768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6769       };
6770     }
6771   }
6772
6773 }
6774
6775
6776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6777   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6778   Dali::Vector3 *arg2 = 0 ;
6779   Dali::Vector3 *arg3 = 0 ;
6780
6781   arg1 = (Dali::Vector3 *)jarg1;
6782   arg2 = (Dali::Vector3 *)jarg2;
6783   if (!arg2) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   arg3 = (Dali::Vector3 *)jarg3;
6788   if (!arg3) {
6789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6790     return ;
6791   }
6792   {
6793     try {
6794       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6795     } catch (std::out_of_range& e) {
6796       {
6797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6798       };
6799     } catch (std::exception& e) {
6800       {
6801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6802       };
6803     } catch (Dali::DaliException e) {
6804       {
6805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6806       };
6807     } catch (...) {
6808       {
6809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6810       };
6811     }
6812   }
6813
6814 }
6815
6816
6817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6818   void * jresult ;
6819   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6820   float *result = 0 ;
6821
6822   arg1 = (Dali::Vector3 *)jarg1;
6823   {
6824     try {
6825       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6826     } catch (std::out_of_range& e) {
6827       {
6828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6829       };
6830     } catch (std::exception& e) {
6831       {
6832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6833       };
6834     } catch (Dali::DaliException e) {
6835       {
6836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6837       };
6838     } catch (...) {
6839       {
6840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6841       };
6842     }
6843   }
6844
6845   jresult = (void *)result;
6846   return jresult;
6847 }
6848
6849
6850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6851   void * jresult ;
6852   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6853   Dali::Vector2 *result = 0 ;
6854
6855   arg1 = (Dali::Vector3 *)jarg1;
6856   {
6857     try {
6858       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6859     } catch (std::out_of_range& e) {
6860       {
6861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6862       };
6863     } catch (std::exception& e) {
6864       {
6865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6866       };
6867     } catch (Dali::DaliException e) {
6868       {
6869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6870       };
6871     } catch (...) {
6872       {
6873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6874       };
6875     }
6876   }
6877
6878   jresult = (void *)result;
6879   return jresult;
6880 }
6881
6882
6883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6884   void * jresult ;
6885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6886   Dali::Vector2 *result = 0 ;
6887
6888   arg1 = (Dali::Vector3 *)jarg1;
6889   {
6890     try {
6891       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6892     } catch (std::out_of_range& e) {
6893       {
6894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6895       };
6896     } catch (std::exception& e) {
6897       {
6898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (Dali::DaliException e) {
6901       {
6902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6903       };
6904     } catch (...) {
6905       {
6906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6907       };
6908     }
6909   }
6910
6911   jresult = (void *)result;
6912   return jresult;
6913 }
6914
6915
6916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6917   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6918   float arg2 ;
6919
6920   arg1 = (Dali::Vector3 *)jarg1;
6921   arg2 = (float)jarg2;
6922   if (arg1) (arg1)->x = arg2;
6923 }
6924
6925
6926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6927   float jresult ;
6928   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6929   float result;
6930
6931   arg1 = (Dali::Vector3 *)jarg1;
6932   result = (float) ((arg1)->x);
6933   jresult = result;
6934   return jresult;
6935 }
6936
6937
6938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6939   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6940   float arg2 ;
6941
6942   arg1 = (Dali::Vector3 *)jarg1;
6943   arg2 = (float)jarg2;
6944   if (arg1) (arg1)->width = arg2;
6945 }
6946
6947
6948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6949   float jresult ;
6950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6951   float result;
6952
6953   arg1 = (Dali::Vector3 *)jarg1;
6954   result = (float) ((arg1)->width);
6955   jresult = result;
6956   return jresult;
6957 }
6958
6959
6960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6962   float arg2 ;
6963
6964   arg1 = (Dali::Vector3 *)jarg1;
6965   arg2 = (float)jarg2;
6966   if (arg1) (arg1)->r = arg2;
6967 }
6968
6969
6970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6971   float jresult ;
6972   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6973   float result;
6974
6975   arg1 = (Dali::Vector3 *)jarg1;
6976   result = (float) ((arg1)->r);
6977   jresult = result;
6978   return jresult;
6979 }
6980
6981
6982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6984   float arg2 ;
6985
6986   arg1 = (Dali::Vector3 *)jarg1;
6987   arg2 = (float)jarg2;
6988   if (arg1) (arg1)->y = arg2;
6989 }
6990
6991
6992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6993   float jresult ;
6994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6995   float result;
6996
6997   arg1 = (Dali::Vector3 *)jarg1;
6998   result = (float) ((arg1)->y);
6999   jresult = result;
7000   return jresult;
7001 }
7002
7003
7004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7006   float arg2 ;
7007
7008   arg1 = (Dali::Vector3 *)jarg1;
7009   arg2 = (float)jarg2;
7010   if (arg1) (arg1)->height = arg2;
7011 }
7012
7013
7014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7015   float jresult ;
7016   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7017   float result;
7018
7019   arg1 = (Dali::Vector3 *)jarg1;
7020   result = (float) ((arg1)->height);
7021   jresult = result;
7022   return jresult;
7023 }
7024
7025
7026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7027   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7028   float arg2 ;
7029
7030   arg1 = (Dali::Vector3 *)jarg1;
7031   arg2 = (float)jarg2;
7032   if (arg1) (arg1)->g = arg2;
7033 }
7034
7035
7036 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7037   float jresult ;
7038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7039   float result;
7040
7041   arg1 = (Dali::Vector3 *)jarg1;
7042   result = (float) ((arg1)->g);
7043   jresult = result;
7044   return jresult;
7045 }
7046
7047
7048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7050   float arg2 ;
7051
7052   arg1 = (Dali::Vector3 *)jarg1;
7053   arg2 = (float)jarg2;
7054   if (arg1) (arg1)->z = arg2;
7055 }
7056
7057
7058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7059   float jresult ;
7060   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7061   float result;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   result = (float) ((arg1)->z);
7065   jresult = result;
7066   return jresult;
7067 }
7068
7069
7070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7071   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7072   float arg2 ;
7073
7074   arg1 = (Dali::Vector3 *)jarg1;
7075   arg2 = (float)jarg2;
7076   if (arg1) (arg1)->depth = arg2;
7077 }
7078
7079
7080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7081   float jresult ;
7082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7083   float result;
7084
7085   arg1 = (Dali::Vector3 *)jarg1;
7086   result = (float) ((arg1)->depth);
7087   jresult = result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7093   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7094   float arg2 ;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   arg2 = (float)jarg2;
7098   if (arg1) (arg1)->b = arg2;
7099 }
7100
7101
7102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7103   float jresult ;
7104   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7105   float result;
7106
7107   arg1 = (Dali::Vector3 *)jarg1;
7108   result = (float) ((arg1)->b);
7109   jresult = result;
7110   return jresult;
7111 }
7112
7113
7114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7115   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7116
7117   arg1 = (Dali::Vector3 *)jarg1;
7118   {
7119     try {
7120       delete arg1;
7121     } catch (std::out_of_range& e) {
7122       {
7123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7124       };
7125     } catch (std::exception& e) {
7126       {
7127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7128       };
7129     } catch (Dali::DaliException e) {
7130       {
7131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7132       };
7133     } catch (...) {
7134       {
7135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7136       };
7137     }
7138   }
7139
7140 }
7141
7142
7143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7144   void * jresult ;
7145   Dali::Vector3 *arg1 = 0 ;
7146   Dali::Vector3 *arg2 = 0 ;
7147   Dali::Vector3 result;
7148
7149   arg1 = (Dali::Vector3 *)jarg1;
7150   if (!arg1) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   arg2 = (Dali::Vector3 *)jarg2;
7155   if (!arg2) {
7156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7157     return 0;
7158   }
7159   {
7160     try {
7161       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7162     } catch (std::out_of_range& e) {
7163       {
7164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7165       };
7166     } catch (std::exception& e) {
7167       {
7168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7169       };
7170     } catch (Dali::DaliException e) {
7171       {
7172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7173       };
7174     } catch (...) {
7175       {
7176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7177       };
7178     }
7179   }
7180
7181   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7187   void * jresult ;
7188   Dali::Vector3 *arg1 = 0 ;
7189   Dali::Vector3 *arg2 = 0 ;
7190   Dali::Vector3 result;
7191
7192   arg1 = (Dali::Vector3 *)jarg1;
7193   if (!arg1) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   arg2 = (Dali::Vector3 *)jarg2;
7198   if (!arg2) {
7199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7200     return 0;
7201   }
7202   {
7203     try {
7204       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7205     } catch (std::out_of_range& e) {
7206       {
7207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (std::exception& e) {
7210       {
7211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7212       };
7213     } catch (Dali::DaliException e) {
7214       {
7215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7216       };
7217     } catch (...) {
7218       {
7219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7220       };
7221     }
7222   }
7223
7224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7225   return jresult;
7226 }
7227
7228
7229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7230   void * jresult ;
7231   Dali::Vector3 *arg1 = 0 ;
7232   float *arg2 = 0 ;
7233   float *arg3 = 0 ;
7234   float temp2 ;
7235   float temp3 ;
7236   Dali::Vector3 result;
7237
7238   arg1 = (Dali::Vector3 *)jarg1;
7239   if (!arg1) {
7240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7241     return 0;
7242   }
7243   temp2 = (float)jarg2;
7244   arg2 = &temp2;
7245   temp3 = (float)jarg3;
7246   arg3 = &temp3;
7247   {
7248     try {
7249       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7250     } catch (std::out_of_range& e) {
7251       {
7252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7253       };
7254     } catch (std::exception& e) {
7255       {
7256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7257       };
7258     } catch (Dali::DaliException e) {
7259       {
7260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7261       };
7262     } catch (...) {
7263       {
7264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7265       };
7266     }
7267   }
7268
7269   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7270   return jresult;
7271 }
7272
7273
7274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7275   void * jresult ;
7276   Dali::Vector4 *result = 0 ;
7277
7278   {
7279     try {
7280       result = (Dali::Vector4 *)new Dali::Vector4();
7281     } catch (std::out_of_range& e) {
7282       {
7283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7284       };
7285     } catch (std::exception& e) {
7286       {
7287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7288       };
7289     } catch (Dali::DaliException e) {
7290       {
7291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7292       };
7293     } catch (...) {
7294       {
7295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7296       };
7297     }
7298   }
7299
7300   jresult = (void *)result;
7301   return jresult;
7302 }
7303
7304
7305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7306   void * jresult ;
7307   float arg1 ;
7308   float arg2 ;
7309   float arg3 ;
7310   float arg4 ;
7311   Dali::Vector4 *result = 0 ;
7312
7313   arg1 = (float)jarg1;
7314   arg2 = (float)jarg2;
7315   arg3 = (float)jarg3;
7316   arg4 = (float)jarg4;
7317   {
7318     try {
7319       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7320     } catch (std::out_of_range& e) {
7321       {
7322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7323       };
7324     } catch (std::exception& e) {
7325       {
7326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7327       };
7328     } catch (Dali::DaliException e) {
7329       {
7330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7331       };
7332     } catch (...) {
7333       {
7334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7335       };
7336     }
7337   }
7338
7339   jresult = (void *)result;
7340   return jresult;
7341 }
7342
7343
7344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7345   void * jresult ;
7346   float *arg1 = (float *) 0 ;
7347   Dali::Vector4 *result = 0 ;
7348
7349   arg1 = jarg1;
7350   {
7351     try {
7352       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7353     } catch (std::out_of_range& e) {
7354       {
7355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7356       };
7357     } catch (std::exception& e) {
7358       {
7359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7360       };
7361     } catch (Dali::DaliException e) {
7362       {
7363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7364       };
7365     } catch (...) {
7366       {
7367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7368       };
7369     }
7370   }
7371
7372   jresult = (void *)result;
7373
7374
7375   return jresult;
7376 }
7377
7378
7379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7380   void * jresult ;
7381   Dali::Vector2 *arg1 = 0 ;
7382   Dali::Vector4 *result = 0 ;
7383
7384   arg1 = (Dali::Vector2 *)jarg1;
7385   if (!arg1) {
7386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7387     return 0;
7388   }
7389   {
7390     try {
7391       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7392     } catch (std::out_of_range& e) {
7393       {
7394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7395       };
7396     } catch (std::exception& e) {
7397       {
7398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7399       };
7400     } catch (Dali::DaliException e) {
7401       {
7402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7403       };
7404     } catch (...) {
7405       {
7406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7407       };
7408     }
7409   }
7410
7411   jresult = (void *)result;
7412   return jresult;
7413 }
7414
7415
7416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7417   void * jresult ;
7418   Dali::Vector3 *arg1 = 0 ;
7419   Dali::Vector4 *result = 0 ;
7420
7421   arg1 = (Dali::Vector3 *)jarg1;
7422   if (!arg1) {
7423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7424     return 0;
7425   }
7426   {
7427     try {
7428       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7429     } catch (std::out_of_range& e) {
7430       {
7431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (std::exception& e) {
7434       {
7435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (Dali::DaliException e) {
7438       {
7439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7440       };
7441     } catch (...) {
7442       {
7443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7444       };
7445     }
7446   }
7447
7448   jresult = (void *)result;
7449   return jresult;
7450 }
7451
7452
7453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7454   void * jresult ;
7455   Dali::Vector4 *result = 0 ;
7456
7457   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7458   jresult = (void *)result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7464   void * jresult ;
7465   Dali::Vector4 *result = 0 ;
7466
7467   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7468   jresult = (void *)result;
7469   return jresult;
7470 }
7471
7472
7473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7474   void * jresult ;
7475   Dali::Vector4 *result = 0 ;
7476
7477   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7478   jresult = (void *)result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7484   void * jresult ;
7485   Dali::Vector4 *result = 0 ;
7486
7487   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7488   jresult = (void *)result;
7489   return jresult;
7490 }
7491
7492
7493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7494   void * jresult ;
7495   Dali::Vector4 *result = 0 ;
7496
7497   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7498   jresult = (void *)result;
7499   return jresult;
7500 }
7501
7502
7503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7504   void * jresult ;
7505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7506   float *arg2 = (float *) 0 ;
7507   Dali::Vector4 *result = 0 ;
7508
7509   arg1 = (Dali::Vector4 *)jarg1;
7510   arg2 = jarg2;
7511   {
7512     try {
7513       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7514     } catch (std::out_of_range& e) {
7515       {
7516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7517       };
7518     } catch (std::exception& e) {
7519       {
7520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7521       };
7522     } catch (Dali::DaliException e) {
7523       {
7524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7525       };
7526     } catch (...) {
7527       {
7528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7529       };
7530     }
7531   }
7532
7533   jresult = (void *)result;
7534
7535
7536   return jresult;
7537 }
7538
7539
7540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7541   void * jresult ;
7542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7543   Dali::Vector2 *arg2 = 0 ;
7544   Dali::Vector4 *result = 0 ;
7545
7546   arg1 = (Dali::Vector4 *)jarg1;
7547   arg2 = (Dali::Vector2 *)jarg2;
7548   if (!arg2) {
7549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7550     return 0;
7551   }
7552   {
7553     try {
7554       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7555     } catch (std::out_of_range& e) {
7556       {
7557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7558       };
7559     } catch (std::exception& e) {
7560       {
7561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7562       };
7563     } catch (Dali::DaliException e) {
7564       {
7565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7566       };
7567     } catch (...) {
7568       {
7569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7570       };
7571     }
7572   }
7573
7574   jresult = (void *)result;
7575   return jresult;
7576 }
7577
7578
7579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7580   void * jresult ;
7581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7582   Dali::Vector3 *arg2 = 0 ;
7583   Dali::Vector4 *result = 0 ;
7584
7585   arg1 = (Dali::Vector4 *)jarg1;
7586   arg2 = (Dali::Vector3 *)jarg2;
7587   if (!arg2) {
7588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7589     return 0;
7590   }
7591   {
7592     try {
7593       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7594     } catch (std::out_of_range& e) {
7595       {
7596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7597       };
7598     } catch (std::exception& e) {
7599       {
7600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7601       };
7602     } catch (Dali::DaliException e) {
7603       {
7604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7605       };
7606     } catch (...) {
7607       {
7608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7609       };
7610     }
7611   }
7612
7613   jresult = (void *)result;
7614   return jresult;
7615 }
7616
7617
7618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7619   void * jresult ;
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   Dali::Vector4 *arg2 = 0 ;
7622   Dali::Vector4 result;
7623
7624   arg1 = (Dali::Vector4 *)jarg1;
7625   arg2 = (Dali::Vector4 *)jarg2;
7626   if (!arg2) {
7627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7628     return 0;
7629   }
7630   {
7631     try {
7632       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7633     } catch (std::out_of_range& e) {
7634       {
7635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7636       };
7637     } catch (std::exception& e) {
7638       {
7639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7640       };
7641     } catch (Dali::DaliException e) {
7642       {
7643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7644       };
7645     } catch (...) {
7646       {
7647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7648       };
7649     }
7650   }
7651
7652   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7653   return jresult;
7654 }
7655
7656
7657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7658   void * jresult ;
7659   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7660   Dali::Vector4 *arg2 = 0 ;
7661   Dali::Vector4 *result = 0 ;
7662
7663   arg1 = (Dali::Vector4 *)jarg1;
7664   arg2 = (Dali::Vector4 *)jarg2;
7665   if (!arg2) {
7666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7667     return 0;
7668   }
7669   {
7670     try {
7671       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7672     } catch (std::out_of_range& e) {
7673       {
7674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7675       };
7676     } catch (std::exception& e) {
7677       {
7678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7679       };
7680     } catch (Dali::DaliException e) {
7681       {
7682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7683       };
7684     } catch (...) {
7685       {
7686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7687       };
7688     }
7689   }
7690
7691   jresult = (void *)result;
7692   return jresult;
7693 }
7694
7695
7696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7697   void * jresult ;
7698   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7699   Dali::Vector4 *arg2 = 0 ;
7700   Dali::Vector4 result;
7701
7702   arg1 = (Dali::Vector4 *)jarg1;
7703   arg2 = (Dali::Vector4 *)jarg2;
7704   if (!arg2) {
7705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7706     return 0;
7707   }
7708   {
7709     try {
7710       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7711     } catch (std::out_of_range& e) {
7712       {
7713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7714       };
7715     } catch (std::exception& e) {
7716       {
7717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7718       };
7719     } catch (Dali::DaliException e) {
7720       {
7721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7722       };
7723     } catch (...) {
7724       {
7725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7726       };
7727     }
7728   }
7729
7730   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7731   return jresult;
7732 }
7733
7734
7735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7736   void * jresult ;
7737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7738   Dali::Vector4 *arg2 = 0 ;
7739   Dali::Vector4 *result = 0 ;
7740
7741   arg1 = (Dali::Vector4 *)jarg1;
7742   arg2 = (Dali::Vector4 *)jarg2;
7743   if (!arg2) {
7744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7745     return 0;
7746   }
7747   {
7748     try {
7749       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7750     } catch (std::out_of_range& e) {
7751       {
7752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7753       };
7754     } catch (std::exception& e) {
7755       {
7756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7757       };
7758     } catch (Dali::DaliException e) {
7759       {
7760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7761       };
7762     } catch (...) {
7763       {
7764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7765       };
7766     }
7767   }
7768
7769   jresult = (void *)result;
7770   return jresult;
7771 }
7772
7773
7774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7775   void * jresult ;
7776   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7777   Dali::Vector4 *arg2 = 0 ;
7778   Dali::Vector4 result;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   arg2 = (Dali::Vector4 *)jarg2;
7782   if (!arg2) {
7783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7784     return 0;
7785   }
7786   {
7787     try {
7788       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7789     } catch (std::out_of_range& e) {
7790       {
7791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7792       };
7793     } catch (std::exception& e) {
7794       {
7795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7796       };
7797     } catch (Dali::DaliException e) {
7798       {
7799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7800       };
7801     } catch (...) {
7802       {
7803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7804       };
7805     }
7806   }
7807
7808   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7814   void * jresult ;
7815   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7816   float arg2 ;
7817   Dali::Vector4 result;
7818
7819   arg1 = (Dali::Vector4 *)jarg1;
7820   arg2 = (float)jarg2;
7821   {
7822     try {
7823       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7824     } catch (std::out_of_range& e) {
7825       {
7826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7827       };
7828     } catch (std::exception& e) {
7829       {
7830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7831       };
7832     } catch (Dali::DaliException e) {
7833       {
7834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7835       };
7836     } catch (...) {
7837       {
7838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7839       };
7840     }
7841   }
7842
7843   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7844   return jresult;
7845 }
7846
7847
7848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7849   void * jresult ;
7850   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7851   Dali::Vector4 *arg2 = 0 ;
7852   Dali::Vector4 *result = 0 ;
7853
7854   arg1 = (Dali::Vector4 *)jarg1;
7855   arg2 = (Dali::Vector4 *)jarg2;
7856   if (!arg2) {
7857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7858     return 0;
7859   }
7860   {
7861     try {
7862       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7863     } catch (std::out_of_range& e) {
7864       {
7865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7866       };
7867     } catch (std::exception& e) {
7868       {
7869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7870       };
7871     } catch (Dali::DaliException e) {
7872       {
7873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7874       };
7875     } catch (...) {
7876       {
7877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7878       };
7879     }
7880   }
7881
7882   jresult = (void *)result;
7883   return jresult;
7884 }
7885
7886
7887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7888   void * jresult ;
7889   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7890   float arg2 ;
7891   Dali::Vector4 *result = 0 ;
7892
7893   arg1 = (Dali::Vector4 *)jarg1;
7894   arg2 = (float)jarg2;
7895   {
7896     try {
7897       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7898     } catch (std::out_of_range& e) {
7899       {
7900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7901       };
7902     } catch (std::exception& e) {
7903       {
7904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7905       };
7906     } catch (Dali::DaliException e) {
7907       {
7908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7909       };
7910     } catch (...) {
7911       {
7912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7913       };
7914     }
7915   }
7916
7917   jresult = (void *)result;
7918   return jresult;
7919 }
7920
7921
7922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7923   void * jresult ;
7924   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7925   Dali::Vector4 *arg2 = 0 ;
7926   Dali::Vector4 result;
7927
7928   arg1 = (Dali::Vector4 *)jarg1;
7929   arg2 = (Dali::Vector4 *)jarg2;
7930   if (!arg2) {
7931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7932     return 0;
7933   }
7934   {
7935     try {
7936       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7937     } catch (std::out_of_range& e) {
7938       {
7939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7940       };
7941     } catch (std::exception& e) {
7942       {
7943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7944       };
7945     } catch (Dali::DaliException e) {
7946       {
7947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7948       };
7949     } catch (...) {
7950       {
7951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7952       };
7953     }
7954   }
7955
7956   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7957   return jresult;
7958 }
7959
7960
7961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7962   void * jresult ;
7963   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7964   float arg2 ;
7965   Dali::Vector4 result;
7966
7967   arg1 = (Dali::Vector4 *)jarg1;
7968   arg2 = (float)jarg2;
7969   {
7970     try {
7971       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7972     } catch (std::out_of_range& e) {
7973       {
7974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7975       };
7976     } catch (std::exception& e) {
7977       {
7978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7979       };
7980     } catch (Dali::DaliException e) {
7981       {
7982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7983       };
7984     } catch (...) {
7985       {
7986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7987       };
7988     }
7989   }
7990
7991   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7992   return jresult;
7993 }
7994
7995
7996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7997   void * jresult ;
7998   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7999   Dali::Vector4 *arg2 = 0 ;
8000   Dali::Vector4 *result = 0 ;
8001
8002   arg1 = (Dali::Vector4 *)jarg1;
8003   arg2 = (Dali::Vector4 *)jarg2;
8004   if (!arg2) {
8005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8006     return 0;
8007   }
8008   {
8009     try {
8010       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8011     } catch (std::out_of_range& e) {
8012       {
8013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8014       };
8015     } catch (std::exception& e) {
8016       {
8017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8018       };
8019     } catch (Dali::DaliException e) {
8020       {
8021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8022       };
8023     } catch (...) {
8024       {
8025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8026       };
8027     }
8028   }
8029
8030   jresult = (void *)result;
8031   return jresult;
8032 }
8033
8034
8035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8036   void * jresult ;
8037   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8038   float arg2 ;
8039   Dali::Vector4 *result = 0 ;
8040
8041   arg1 = (Dali::Vector4 *)jarg1;
8042   arg2 = (float)jarg2;
8043   {
8044     try {
8045       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8046     } catch (std::out_of_range& e) {
8047       {
8048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8049       };
8050     } catch (std::exception& e) {
8051       {
8052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8053       };
8054     } catch (Dali::DaliException e) {
8055       {
8056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8057       };
8058     } catch (...) {
8059       {
8060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8061       };
8062     }
8063   }
8064
8065   jresult = (void *)result;
8066   return jresult;
8067 }
8068
8069
8070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8071   void * jresult ;
8072   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8073   Dali::Vector4 result;
8074
8075   arg1 = (Dali::Vector4 *)jarg1;
8076   {
8077     try {
8078       result = ((Dali::Vector4 const *)arg1)->operator -();
8079     } catch (std::out_of_range& e) {
8080       {
8081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8082       };
8083     } catch (std::exception& e) {
8084       {
8085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8086       };
8087     } catch (Dali::DaliException e) {
8088       {
8089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8090       };
8091     } catch (...) {
8092       {
8093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8094       };
8095     }
8096   }
8097
8098   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8099   return jresult;
8100 }
8101
8102
8103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8104   unsigned int jresult ;
8105   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8106   Dali::Vector4 *arg2 = 0 ;
8107   bool result;
8108
8109   arg1 = (Dali::Vector4 *)jarg1;
8110   arg2 = (Dali::Vector4 *)jarg2;
8111   if (!arg2) {
8112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8113     return 0;
8114   }
8115   {
8116     try {
8117       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8118     } catch (std::out_of_range& e) {
8119       {
8120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8121       };
8122     } catch (std::exception& e) {
8123       {
8124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8125       };
8126     } catch (Dali::DaliException e) {
8127       {
8128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8129       };
8130     } catch (...) {
8131       {
8132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8133       };
8134     }
8135   }
8136
8137   jresult = result;
8138   return jresult;
8139 }
8140
8141
8142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8143   unsigned int jresult ;
8144   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8145   Dali::Vector4 *arg2 = 0 ;
8146   bool result;
8147
8148   arg1 = (Dali::Vector4 *)jarg1;
8149   arg2 = (Dali::Vector4 *)jarg2;
8150   if (!arg2) {
8151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8152     return 0;
8153   }
8154   {
8155     try {
8156       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8157     } catch (std::out_of_range& e) {
8158       {
8159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8160       };
8161     } catch (std::exception& e) {
8162       {
8163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8164       };
8165     } catch (Dali::DaliException e) {
8166       {
8167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8168       };
8169     } catch (...) {
8170       {
8171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8172       };
8173     }
8174   }
8175
8176   jresult = result;
8177   return jresult;
8178 }
8179
8180
8181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8182   float jresult ;
8183   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8184   unsigned int arg2 ;
8185   float *result = 0 ;
8186
8187   arg1 = (Dali::Vector4 *)jarg1;
8188   arg2 = (unsigned int)jarg2;
8189   {
8190     try {
8191       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8192     } catch (std::out_of_range& e) {
8193       {
8194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8195       };
8196     } catch (std::exception& e) {
8197       {
8198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8199       };
8200     } catch (Dali::DaliException e) {
8201       {
8202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8203       };
8204     } catch (...) {
8205       {
8206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8207       };
8208     }
8209   }
8210
8211   jresult = *result;
8212   return jresult;
8213 }
8214
8215
8216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8217   float jresult ;
8218   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8219   Dali::Vector3 *arg2 = 0 ;
8220   float result;
8221
8222   arg1 = (Dali::Vector4 *)jarg1;
8223   arg2 = (Dali::Vector3 *)jarg2;
8224   if (!arg2) {
8225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8226     return 0;
8227   }
8228   {
8229     try {
8230       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8231     } catch (std::out_of_range& e) {
8232       {
8233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8234       };
8235     } catch (std::exception& e) {
8236       {
8237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8238       };
8239     } catch (Dali::DaliException e) {
8240       {
8241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8242       };
8243     } catch (...) {
8244       {
8245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8246       };
8247     }
8248   }
8249
8250   jresult = result;
8251   return jresult;
8252 }
8253
8254
8255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8256   float jresult ;
8257   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8258   Dali::Vector4 *arg2 = 0 ;
8259   float result;
8260
8261   arg1 = (Dali::Vector4 *)jarg1;
8262   arg2 = (Dali::Vector4 *)jarg2;
8263   if (!arg2) {
8264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8265     return 0;
8266   }
8267   {
8268     try {
8269       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8270     } catch (std::out_of_range& e) {
8271       {
8272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8273       };
8274     } catch (std::exception& e) {
8275       {
8276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8277       };
8278     } catch (Dali::DaliException e) {
8279       {
8280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8281       };
8282     } catch (...) {
8283       {
8284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8285       };
8286     }
8287   }
8288
8289   jresult = result;
8290   return jresult;
8291 }
8292
8293
8294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8295   float jresult ;
8296   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8297   Dali::Vector4 *arg2 = 0 ;
8298   float result;
8299
8300   arg1 = (Dali::Vector4 *)jarg1;
8301   arg2 = (Dali::Vector4 *)jarg2;
8302   if (!arg2) {
8303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8304     return 0;
8305   }
8306   {
8307     try {
8308       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8309     } catch (std::out_of_range& e) {
8310       {
8311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8312       };
8313     } catch (std::exception& e) {
8314       {
8315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8316       };
8317     } catch (Dali::DaliException e) {
8318       {
8319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8320       };
8321     } catch (...) {
8322       {
8323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8324       };
8325     }
8326   }
8327
8328   jresult = result;
8329   return jresult;
8330 }
8331
8332
8333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8334   void * jresult ;
8335   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8336   Dali::Vector4 *arg2 = 0 ;
8337   Dali::Vector4 result;
8338
8339   arg1 = (Dali::Vector4 *)jarg1;
8340   arg2 = (Dali::Vector4 *)jarg2;
8341   if (!arg2) {
8342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8343     return 0;
8344   }
8345   {
8346     try {
8347       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8348     } catch (std::out_of_range& e) {
8349       {
8350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8351       };
8352     } catch (std::exception& e) {
8353       {
8354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (Dali::DaliException e) {
8357       {
8358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8359       };
8360     } catch (...) {
8361       {
8362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8363       };
8364     }
8365   }
8366
8367   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8368   return jresult;
8369 }
8370
8371
8372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8373   float jresult ;
8374   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8375   float result;
8376
8377   arg1 = (Dali::Vector4 *)jarg1;
8378   {
8379     try {
8380       result = (float)((Dali::Vector4 const *)arg1)->Length();
8381     } catch (std::out_of_range& e) {
8382       {
8383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8384       };
8385     } catch (std::exception& e) {
8386       {
8387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8388       };
8389     } catch (Dali::DaliException e) {
8390       {
8391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8392       };
8393     } catch (...) {
8394       {
8395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8396       };
8397     }
8398   }
8399
8400   jresult = result;
8401   return jresult;
8402 }
8403
8404
8405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8406   float jresult ;
8407   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8408   float result;
8409
8410   arg1 = (Dali::Vector4 *)jarg1;
8411   {
8412     try {
8413       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8414     } catch (std::out_of_range& e) {
8415       {
8416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8417       };
8418     } catch (std::exception& e) {
8419       {
8420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8421       };
8422     } catch (Dali::DaliException e) {
8423       {
8424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8425       };
8426     } catch (...) {
8427       {
8428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8429       };
8430     }
8431   }
8432
8433   jresult = result;
8434   return jresult;
8435 }
8436
8437
8438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8439   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8440
8441   arg1 = (Dali::Vector4 *)jarg1;
8442   {
8443     try {
8444       (arg1)->Normalize();
8445     } catch (std::out_of_range& e) {
8446       {
8447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8448       };
8449     } catch (std::exception& e) {
8450       {
8451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8452       };
8453     } catch (Dali::DaliException e) {
8454       {
8455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8456       };
8457     } catch (...) {
8458       {
8459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8460       };
8461     }
8462   }
8463
8464 }
8465
8466
8467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8468   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8469   Dali::Vector4 *arg2 = 0 ;
8470   Dali::Vector4 *arg3 = 0 ;
8471
8472   arg1 = (Dali::Vector4 *)jarg1;
8473   arg2 = (Dali::Vector4 *)jarg2;
8474   if (!arg2) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   arg3 = (Dali::Vector4 *)jarg3;
8479   if (!arg3) {
8480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8481     return ;
8482   }
8483   {
8484     try {
8485       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8486     } catch (std::out_of_range& e) {
8487       {
8488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8489       };
8490     } catch (std::exception& e) {
8491       {
8492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8493       };
8494     } catch (Dali::DaliException e) {
8495       {
8496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8497       };
8498     } catch (...) {
8499       {
8500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8501       };
8502     }
8503   }
8504
8505 }
8506
8507
8508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8509   void * jresult ;
8510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8511   float *result = 0 ;
8512
8513   arg1 = (Dali::Vector4 *)jarg1;
8514   {
8515     try {
8516       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8517     } catch (std::out_of_range& e) {
8518       {
8519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8520       };
8521     } catch (std::exception& e) {
8522       {
8523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8524       };
8525     } catch (Dali::DaliException e) {
8526       {
8527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8528       };
8529     } catch (...) {
8530       {
8531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8532       };
8533     }
8534   }
8535
8536   jresult = (void *)result;
8537   return jresult;
8538 }
8539
8540
8541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8542   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8543   float arg2 ;
8544
8545   arg1 = (Dali::Vector4 *)jarg1;
8546   arg2 = (float)jarg2;
8547   if (arg1) (arg1)->x = arg2;
8548 }
8549
8550
8551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8552   float jresult ;
8553   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8554   float result;
8555
8556   arg1 = (Dali::Vector4 *)jarg1;
8557   result = (float) ((arg1)->x);
8558   jresult = result;
8559   return jresult;
8560 }
8561
8562
8563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8565   float arg2 ;
8566
8567   arg1 = (Dali::Vector4 *)jarg1;
8568   arg2 = (float)jarg2;
8569   if (arg1) (arg1)->r = arg2;
8570 }
8571
8572
8573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8574   float jresult ;
8575   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8576   float result;
8577
8578   arg1 = (Dali::Vector4 *)jarg1;
8579   result = (float) ((arg1)->r);
8580   jresult = result;
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8586   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8587   float arg2 ;
8588
8589   arg1 = (Dali::Vector4 *)jarg1;
8590   arg2 = (float)jarg2;
8591   if (arg1) (arg1)->s = arg2;
8592 }
8593
8594
8595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8596   float jresult ;
8597   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8598   float result;
8599
8600   arg1 = (Dali::Vector4 *)jarg1;
8601   result = (float) ((arg1)->s);
8602   jresult = result;
8603   return jresult;
8604 }
8605
8606
8607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8608   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8609   float arg2 ;
8610
8611   arg1 = (Dali::Vector4 *)jarg1;
8612   arg2 = (float)jarg2;
8613   if (arg1) (arg1)->y = arg2;
8614 }
8615
8616
8617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8618   float jresult ;
8619   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8620   float result;
8621
8622   arg1 = (Dali::Vector4 *)jarg1;
8623   result = (float) ((arg1)->y);
8624   jresult = result;
8625   return jresult;
8626 }
8627
8628
8629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8630   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8631   float arg2 ;
8632
8633   arg1 = (Dali::Vector4 *)jarg1;
8634   arg2 = (float)jarg2;
8635   if (arg1) (arg1)->g = arg2;
8636 }
8637
8638
8639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8640   float jresult ;
8641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8642   float result;
8643
8644   arg1 = (Dali::Vector4 *)jarg1;
8645   result = (float) ((arg1)->g);
8646   jresult = result;
8647   return jresult;
8648 }
8649
8650
8651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8653   float arg2 ;
8654
8655   arg1 = (Dali::Vector4 *)jarg1;
8656   arg2 = (float)jarg2;
8657   if (arg1) (arg1)->t = arg2;
8658 }
8659
8660
8661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8662   float jresult ;
8663   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8664   float result;
8665
8666   arg1 = (Dali::Vector4 *)jarg1;
8667   result = (float) ((arg1)->t);
8668   jresult = result;
8669   return jresult;
8670 }
8671
8672
8673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8674   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8675   float arg2 ;
8676
8677   arg1 = (Dali::Vector4 *)jarg1;
8678   arg2 = (float)jarg2;
8679   if (arg1) (arg1)->z = arg2;
8680 }
8681
8682
8683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8684   float jresult ;
8685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8686   float result;
8687
8688   arg1 = (Dali::Vector4 *)jarg1;
8689   result = (float) ((arg1)->z);
8690   jresult = result;
8691   return jresult;
8692 }
8693
8694
8695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8697   float arg2 ;
8698
8699   arg1 = (Dali::Vector4 *)jarg1;
8700   arg2 = (float)jarg2;
8701   if (arg1) (arg1)->b = arg2;
8702 }
8703
8704
8705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8706   float jresult ;
8707   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8708   float result;
8709
8710   arg1 = (Dali::Vector4 *)jarg1;
8711   result = (float) ((arg1)->b);
8712   jresult = result;
8713   return jresult;
8714 }
8715
8716
8717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8718   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8719   float arg2 ;
8720
8721   arg1 = (Dali::Vector4 *)jarg1;
8722   arg2 = (float)jarg2;
8723   if (arg1) (arg1)->p = arg2;
8724 }
8725
8726
8727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8728   float jresult ;
8729   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8730   float result;
8731
8732   arg1 = (Dali::Vector4 *)jarg1;
8733   result = (float) ((arg1)->p);
8734   jresult = result;
8735   return jresult;
8736 }
8737
8738
8739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8740   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8741   float arg2 ;
8742
8743   arg1 = (Dali::Vector4 *)jarg1;
8744   arg2 = (float)jarg2;
8745   if (arg1) (arg1)->w = arg2;
8746 }
8747
8748
8749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8750   float jresult ;
8751   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8752   float result;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   result = (float) ((arg1)->w);
8756   jresult = result;
8757   return jresult;
8758 }
8759
8760
8761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8762   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8763   float arg2 ;
8764
8765   arg1 = (Dali::Vector4 *)jarg1;
8766   arg2 = (float)jarg2;
8767   if (arg1) (arg1)->a = arg2;
8768 }
8769
8770
8771 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8772   float jresult ;
8773   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8774   float result;
8775
8776   arg1 = (Dali::Vector4 *)jarg1;
8777   result = (float) ((arg1)->a);
8778   jresult = result;
8779   return jresult;
8780 }
8781
8782
8783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8784   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8785   float arg2 ;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   arg2 = (float)jarg2;
8789   if (arg1) (arg1)->q = arg2;
8790 }
8791
8792
8793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8794   float jresult ;
8795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8796   float result;
8797
8798   arg1 = (Dali::Vector4 *)jarg1;
8799   result = (float) ((arg1)->q);
8800   jresult = result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8806   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8807
8808   arg1 = (Dali::Vector4 *)jarg1;
8809   {
8810     try {
8811       delete arg1;
8812     } catch (std::out_of_range& e) {
8813       {
8814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8815       };
8816     } catch (std::exception& e) {
8817       {
8818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8819       };
8820     } catch (Dali::DaliException e) {
8821       {
8822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8823       };
8824     } catch (...) {
8825       {
8826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8827       };
8828     }
8829   }
8830
8831 }
8832
8833
8834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8835   void * jresult ;
8836   Dali::Vector4 *arg1 = 0 ;
8837   Dali::Vector4 *arg2 = 0 ;
8838   Dali::Vector4 result;
8839
8840   arg1 = (Dali::Vector4 *)jarg1;
8841   if (!arg1) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   arg2 = (Dali::Vector4 *)jarg2;
8846   if (!arg2) {
8847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8848     return 0;
8849   }
8850   {
8851     try {
8852       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8853     } catch (std::out_of_range& e) {
8854       {
8855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8856       };
8857     } catch (std::exception& e) {
8858       {
8859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8860       };
8861     } catch (Dali::DaliException e) {
8862       {
8863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8864       };
8865     } catch (...) {
8866       {
8867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8868       };
8869     }
8870   }
8871
8872   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8873   return jresult;
8874 }
8875
8876
8877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8878   void * jresult ;
8879   Dali::Vector4 *arg1 = 0 ;
8880   Dali::Vector4 *arg2 = 0 ;
8881   Dali::Vector4 result;
8882
8883   arg1 = (Dali::Vector4 *)jarg1;
8884   if (!arg1) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   arg2 = (Dali::Vector4 *)jarg2;
8889   if (!arg2) {
8890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8891     return 0;
8892   }
8893   {
8894     try {
8895       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8896     } catch (std::out_of_range& e) {
8897       {
8898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (std::exception& e) {
8901       {
8902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8903       };
8904     } catch (Dali::DaliException e) {
8905       {
8906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8907       };
8908     } catch (...) {
8909       {
8910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8911       };
8912     }
8913   }
8914
8915   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8916   return jresult;
8917 }
8918
8919
8920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8921   void * jresult ;
8922   Dali::Vector4 *arg1 = 0 ;
8923   float *arg2 = 0 ;
8924   float *arg3 = 0 ;
8925   float temp2 ;
8926   float temp3 ;
8927   Dali::Vector4 result;
8928
8929   arg1 = (Dali::Vector4 *)jarg1;
8930   if (!arg1) {
8931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8932     return 0;
8933   }
8934   temp2 = (float)jarg2;
8935   arg2 = &temp2;
8936   temp3 = (float)jarg3;
8937   arg3 = &temp3;
8938   {
8939     try {
8940       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8941     } catch (std::out_of_range& e) {
8942       {
8943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8944       };
8945     } catch (std::exception& e) {
8946       {
8947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8948       };
8949     } catch (Dali::DaliException e) {
8950       {
8951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8952       };
8953     } catch (...) {
8954       {
8955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8956       };
8957     }
8958   }
8959
8960   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8961   return jresult;
8962 }
8963
8964
8965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8966   void * jresult ;
8967   Dali::Uint16Pair *result = 0 ;
8968
8969   {
8970     try {
8971       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8972     } catch (std::out_of_range& e) {
8973       {
8974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8975       };
8976     } catch (std::exception& e) {
8977       {
8978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8979       };
8980     } catch (Dali::DaliException e) {
8981       {
8982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8983       };
8984     } catch (...) {
8985       {
8986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8987       };
8988     }
8989   }
8990
8991   jresult = (void *)result;
8992   return jresult;
8993 }
8994
8995
8996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8997   void * jresult ;
8998   uint32_t arg1 ;
8999   uint32_t arg2 ;
9000   Dali::Uint16Pair *result = 0 ;
9001
9002   arg1 = (uint32_t)jarg1;
9003   arg2 = (uint32_t)jarg2;
9004   {
9005     try {
9006       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9007     } catch (std::out_of_range& e) {
9008       {
9009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9010       };
9011     } catch (std::exception& e) {
9012       {
9013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9014       };
9015     } catch (Dali::DaliException e) {
9016       {
9017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9018       };
9019     } catch (...) {
9020       {
9021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9022       };
9023     }
9024   }
9025
9026   jresult = (void *)result;
9027   return jresult;
9028 }
9029
9030
9031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9032   void * jresult ;
9033   Dali::Uint16Pair *arg1 = 0 ;
9034   Dali::Uint16Pair *result = 0 ;
9035
9036   arg1 = (Dali::Uint16Pair *)jarg1;
9037   if (!arg1) {
9038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9039     return 0;
9040   }
9041   {
9042     try {
9043       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9044     } catch (std::out_of_range& e) {
9045       {
9046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9047       };
9048     } catch (std::exception& e) {
9049       {
9050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9051       };
9052     } catch (Dali::DaliException e) {
9053       {
9054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9055       };
9056     } catch (...) {
9057       {
9058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9059       };
9060     }
9061   }
9062
9063   jresult = (void *)result;
9064   return jresult;
9065 }
9066
9067
9068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9069   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9070   uint16_t arg2 ;
9071
9072   arg1 = (Dali::Uint16Pair *)jarg1;
9073   arg2 = (uint16_t)jarg2;
9074   {
9075     try {
9076       (arg1)->SetWidth(arg2);
9077     } catch (std::out_of_range& e) {
9078       {
9079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9080       };
9081     } catch (std::exception& e) {
9082       {
9083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9084       };
9085     } catch (Dali::DaliException e) {
9086       {
9087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9088       };
9089     } catch (...) {
9090       {
9091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9092       };
9093     }
9094   }
9095
9096 }
9097
9098
9099 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9100   unsigned short jresult ;
9101   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9102   uint16_t result;
9103
9104   arg1 = (Dali::Uint16Pair *)jarg1;
9105   {
9106     try {
9107       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9108     } catch (std::out_of_range& e) {
9109       {
9110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9111       };
9112     } catch (std::exception& e) {
9113       {
9114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9115       };
9116     } catch (Dali::DaliException e) {
9117       {
9118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9119       };
9120     } catch (...) {
9121       {
9122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9123       };
9124     }
9125   }
9126
9127   jresult = result;
9128   return jresult;
9129 }
9130
9131
9132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9133   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9134   uint16_t arg2 ;
9135
9136   arg1 = (Dali::Uint16Pair *)jarg1;
9137   arg2 = (uint16_t)jarg2;
9138   {
9139     try {
9140       (arg1)->SetHeight(arg2);
9141     } catch (std::out_of_range& e) {
9142       {
9143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9144       };
9145     } catch (std::exception& e) {
9146       {
9147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9148       };
9149     } catch (Dali::DaliException e) {
9150       {
9151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9152       };
9153     } catch (...) {
9154       {
9155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9156       };
9157     }
9158   }
9159
9160 }
9161
9162
9163 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9164   unsigned short jresult ;
9165   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9166   uint16_t result;
9167
9168   arg1 = (Dali::Uint16Pair *)jarg1;
9169   {
9170     try {
9171       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9172     } catch (std::out_of_range& e) {
9173       {
9174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9175       };
9176     } catch (std::exception& e) {
9177       {
9178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9179       };
9180     } catch (Dali::DaliException e) {
9181       {
9182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9183       };
9184     } catch (...) {
9185       {
9186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9187       };
9188     }
9189   }
9190
9191   jresult = result;
9192   return jresult;
9193 }
9194
9195
9196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9197   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9198   uint16_t arg2 ;
9199
9200   arg1 = (Dali::Uint16Pair *)jarg1;
9201   arg2 = (uint16_t)jarg2;
9202   {
9203     try {
9204       (arg1)->SetX(arg2);
9205     } catch (std::out_of_range& e) {
9206       {
9207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9208       };
9209     } catch (std::exception& e) {
9210       {
9211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9212       };
9213     } catch (Dali::DaliException e) {
9214       {
9215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9216       };
9217     } catch (...) {
9218       {
9219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9220       };
9221     }
9222   }
9223
9224 }
9225
9226
9227 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9228   unsigned short jresult ;
9229   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9230   uint16_t result;
9231
9232   arg1 = (Dali::Uint16Pair *)jarg1;
9233   {
9234     try {
9235       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9236     } catch (std::out_of_range& e) {
9237       {
9238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9239       };
9240     } catch (std::exception& e) {
9241       {
9242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9243       };
9244     } catch (Dali::DaliException e) {
9245       {
9246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9247       };
9248     } catch (...) {
9249       {
9250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9251       };
9252     }
9253   }
9254
9255   jresult = result;
9256   return jresult;
9257 }
9258
9259
9260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9261   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9262   uint16_t arg2 ;
9263
9264   arg1 = (Dali::Uint16Pair *)jarg1;
9265   arg2 = (uint16_t)jarg2;
9266   {
9267     try {
9268       (arg1)->SetY(arg2);
9269     } catch (std::out_of_range& e) {
9270       {
9271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9272       };
9273     } catch (std::exception& e) {
9274       {
9275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9276       };
9277     } catch (Dali::DaliException e) {
9278       {
9279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9280       };
9281     } catch (...) {
9282       {
9283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9284       };
9285     }
9286   }
9287
9288 }
9289
9290
9291 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9292   unsigned short jresult ;
9293   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9294   uint16_t result;
9295
9296   arg1 = (Dali::Uint16Pair *)jarg1;
9297   {
9298     try {
9299       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9300     } catch (std::out_of_range& e) {
9301       {
9302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9303       };
9304     } catch (std::exception& e) {
9305       {
9306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9307       };
9308     } catch (Dali::DaliException e) {
9309       {
9310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9311       };
9312     } catch (...) {
9313       {
9314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9315       };
9316     }
9317   }
9318
9319   jresult = result;
9320   return jresult;
9321 }
9322
9323
9324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9325   void * jresult ;
9326   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9327   Dali::Uint16Pair *arg2 = 0 ;
9328   Dali::Uint16Pair *result = 0 ;
9329
9330   arg1 = (Dali::Uint16Pair *)jarg1;
9331   arg2 = (Dali::Uint16Pair *)jarg2;
9332   if (!arg2) {
9333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9334     return 0;
9335   }
9336   {
9337     try {
9338       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9339     } catch (std::out_of_range& e) {
9340       {
9341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9342       };
9343     } catch (std::exception& e) {
9344       {
9345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9346       };
9347     } catch (Dali::DaliException e) {
9348       {
9349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9350       };
9351     } catch (...) {
9352       {
9353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9354       };
9355     }
9356   }
9357
9358   jresult = (void *)result;
9359   return jresult;
9360 }
9361
9362
9363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9364   unsigned int jresult ;
9365   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9366   Dali::Uint16Pair *arg2 = 0 ;
9367   bool result;
9368
9369   arg1 = (Dali::Uint16Pair *)jarg1;
9370   arg2 = (Dali::Uint16Pair *)jarg2;
9371   if (!arg2) {
9372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9373     return 0;
9374   }
9375   {
9376     try {
9377       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9378     } catch (std::out_of_range& e) {
9379       {
9380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9381       };
9382     } catch (std::exception& e) {
9383       {
9384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9385       };
9386     } catch (Dali::DaliException e) {
9387       {
9388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9389       };
9390     } catch (...) {
9391       {
9392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9393       };
9394     }
9395   }
9396
9397   jresult = result;
9398   return jresult;
9399 }
9400
9401
9402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9403   unsigned int jresult ;
9404   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9405   Dali::Uint16Pair *arg2 = 0 ;
9406   bool result;
9407
9408   arg1 = (Dali::Uint16Pair *)jarg1;
9409   arg2 = (Dali::Uint16Pair *)jarg2;
9410   if (!arg2) {
9411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9412     return 0;
9413   }
9414   {
9415     try {
9416       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9417     } catch (std::out_of_range& e) {
9418       {
9419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9420       };
9421     } catch (std::exception& e) {
9422       {
9423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9424       };
9425     } catch (Dali::DaliException e) {
9426       {
9427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9428       };
9429     } catch (...) {
9430       {
9431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9432       };
9433     }
9434   }
9435
9436   jresult = result;
9437   return jresult;
9438 }
9439
9440
9441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9442   unsigned int jresult ;
9443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9444   Dali::Uint16Pair *arg2 = 0 ;
9445   bool result;
9446
9447   arg1 = (Dali::Uint16Pair *)jarg1;
9448   arg2 = (Dali::Uint16Pair *)jarg2;
9449   if (!arg2) {
9450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9451     return 0;
9452   }
9453   {
9454     try {
9455       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9456     } catch (std::out_of_range& e) {
9457       {
9458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (std::exception& e) {
9461       {
9462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9463       };
9464     } catch (Dali::DaliException e) {
9465       {
9466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9467       };
9468     } catch (...) {
9469       {
9470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9471       };
9472     }
9473   }
9474
9475   jresult = result;
9476   return jresult;
9477 }
9478
9479
9480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9481   unsigned int jresult ;
9482   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9483   Dali::Uint16Pair *arg2 = 0 ;
9484   bool result;
9485
9486   arg1 = (Dali::Uint16Pair *)jarg1;
9487   arg2 = (Dali::Uint16Pair *)jarg2;
9488   if (!arg2) {
9489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9490     return 0;
9491   }
9492   {
9493     try {
9494       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9495     } catch (std::out_of_range& e) {
9496       {
9497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9498       };
9499     } catch (std::exception& e) {
9500       {
9501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9502       };
9503     } catch (Dali::DaliException e) {
9504       {
9505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9506       };
9507     } catch (...) {
9508       {
9509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9510       };
9511     }
9512   }
9513
9514   jresult = result;
9515   return jresult;
9516 }
9517
9518
9519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9520   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9521
9522   arg1 = (Dali::Uint16Pair *)jarg1;
9523   {
9524     try {
9525       delete arg1;
9526     } catch (std::out_of_range& e) {
9527       {
9528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9529       };
9530     } catch (std::exception& e) {
9531       {
9532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9533       };
9534     } catch (Dali::DaliException e) {
9535       {
9536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9537       };
9538     } catch (...) {
9539       {
9540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9541       };
9542     }
9543   }
9544
9545 }
9546
9547
9548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9549   void * jresult ;
9550   Dali::Degree *result = 0 ;
9551
9552   {
9553     try {
9554       result = (Dali::Degree *)new Dali::Degree();
9555     } catch (std::out_of_range& e) {
9556       {
9557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9558       };
9559     } catch (std::exception& e) {
9560       {
9561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9562       };
9563     } catch (Dali::DaliException e) {
9564       {
9565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9566       };
9567     } catch (...) {
9568       {
9569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9570       };
9571     }
9572   }
9573
9574   jresult = (void *)result;
9575   return jresult;
9576 }
9577
9578
9579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9580   void * jresult ;
9581   float arg1 ;
9582   Dali::Degree *result = 0 ;
9583
9584   arg1 = (float)jarg1;
9585   {
9586     try {
9587       result = (Dali::Degree *)new Dali::Degree(arg1);
9588     } catch (std::out_of_range& e) {
9589       {
9590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9591       };
9592     } catch (std::exception& e) {
9593       {
9594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9595       };
9596     } catch (Dali::DaliException e) {
9597       {
9598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9599       };
9600     } catch (...) {
9601       {
9602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9603       };
9604     }
9605   }
9606
9607   jresult = (void *)result;
9608   return jresult;
9609 }
9610
9611
9612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9613   void * jresult ;
9614   Dali::Radian arg1 ;
9615   Dali::Radian *argp1 ;
9616   Dali::Degree *result = 0 ;
9617
9618   argp1 = (Dali::Radian *)jarg1;
9619   if (!argp1) {
9620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9621     return 0;
9622   }
9623   arg1 = *argp1;
9624   {
9625     try {
9626       result = (Dali::Degree *)new Dali::Degree(arg1);
9627     } catch (std::out_of_range& e) {
9628       {
9629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9630       };
9631     } catch (std::exception& e) {
9632       {
9633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9634       };
9635     } catch (Dali::DaliException e) {
9636       {
9637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9638       };
9639     } catch (...) {
9640       {
9641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9642       };
9643     }
9644   }
9645
9646   jresult = (void *)result;
9647   return jresult;
9648 }
9649
9650
9651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9652   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9653   float arg2 ;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   arg2 = (float)jarg2;
9657   if (arg1) (arg1)->degree = arg2;
9658 }
9659
9660
9661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9662   float jresult ;
9663   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9664   float result;
9665
9666   arg1 = (Dali::Degree *)jarg1;
9667   result = (float) ((arg1)->degree);
9668   jresult = result;
9669   return jresult;
9670 }
9671
9672
9673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9674   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9675
9676   arg1 = (Dali::Degree *)jarg1;
9677   {
9678     try {
9679       delete arg1;
9680     } catch (std::out_of_range& e) {
9681       {
9682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9683       };
9684     } catch (std::exception& e) {
9685       {
9686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9687       };
9688     } catch (Dali::DaliException e) {
9689       {
9690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9691       };
9692     } catch (...) {
9693       {
9694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9695       };
9696     }
9697   }
9698
9699 }
9700
9701
9702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9703   void * jresult ;
9704   Dali::Radian *result = 0 ;
9705
9706   result = (Dali::Radian *)&Dali::ANGLE_360;
9707   jresult = (void *)result;
9708   return jresult;
9709 }
9710
9711
9712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9713   void * jresult ;
9714   Dali::Radian *result = 0 ;
9715
9716   result = (Dali::Radian *)&Dali::ANGLE_315;
9717   jresult = (void *)result;
9718   return jresult;
9719 }
9720
9721
9722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9723   void * jresult ;
9724   Dali::Radian *result = 0 ;
9725
9726   result = (Dali::Radian *)&Dali::ANGLE_270;
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9733   void * jresult ;
9734   Dali::Radian *result = 0 ;
9735
9736   result = (Dali::Radian *)&Dali::ANGLE_225;
9737   jresult = (void *)result;
9738   return jresult;
9739 }
9740
9741
9742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9743   void * jresult ;
9744   Dali::Radian *result = 0 ;
9745
9746   result = (Dali::Radian *)&Dali::ANGLE_180;
9747   jresult = (void *)result;
9748   return jresult;
9749 }
9750
9751
9752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9753   void * jresult ;
9754   Dali::Radian *result = 0 ;
9755
9756   result = (Dali::Radian *)&Dali::ANGLE_135;
9757   jresult = (void *)result;
9758   return jresult;
9759 }
9760
9761
9762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9763   void * jresult ;
9764   Dali::Radian *result = 0 ;
9765
9766   result = (Dali::Radian *)&Dali::ANGLE_120;
9767   jresult = (void *)result;
9768   return jresult;
9769 }
9770
9771
9772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9773   void * jresult ;
9774   Dali::Radian *result = 0 ;
9775
9776   result = (Dali::Radian *)&Dali::ANGLE_90;
9777   jresult = (void *)result;
9778   return jresult;
9779 }
9780
9781
9782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9783   void * jresult ;
9784   Dali::Radian *result = 0 ;
9785
9786   result = (Dali::Radian *)&Dali::ANGLE_60;
9787   jresult = (void *)result;
9788   return jresult;
9789 }
9790
9791
9792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9793   void * jresult ;
9794   Dali::Radian *result = 0 ;
9795
9796   result = (Dali::Radian *)&Dali::ANGLE_45;
9797   jresult = (void *)result;
9798   return jresult;
9799 }
9800
9801
9802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9803   void * jresult ;
9804   Dali::Radian *result = 0 ;
9805
9806   result = (Dali::Radian *)&Dali::ANGLE_30;
9807   jresult = (void *)result;
9808   return jresult;
9809 }
9810
9811
9812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9813   void * jresult ;
9814   Dali::Radian *result = 0 ;
9815
9816   result = (Dali::Radian *)&Dali::ANGLE_0;
9817   jresult = (void *)result;
9818   return jresult;
9819 }
9820
9821
9822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9823   unsigned int jresult ;
9824   Dali::Degree *arg1 = 0 ;
9825   Dali::Degree *arg2 = 0 ;
9826   bool result;
9827
9828   arg1 = (Dali::Degree *)jarg1;
9829   if (!arg1) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   arg2 = (Dali::Degree *)jarg2;
9834   if (!arg2) {
9835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9836     return 0;
9837   }
9838   {
9839     try {
9840       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9841     } catch (std::out_of_range& e) {
9842       {
9843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9844       };
9845     } catch (std::exception& e) {
9846       {
9847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9848       };
9849     } catch (Dali::DaliException e) {
9850       {
9851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9852       };
9853     } catch (...) {
9854       {
9855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9856       };
9857     }
9858   }
9859
9860   jresult = result;
9861   return jresult;
9862 }
9863
9864
9865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9866   unsigned int jresult ;
9867   Dali::Degree *arg1 = 0 ;
9868   Dali::Degree *arg2 = 0 ;
9869   bool result;
9870
9871   arg1 = (Dali::Degree *)jarg1;
9872   if (!arg1) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   arg2 = (Dali::Degree *)jarg2;
9877   if (!arg2) {
9878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9879     return 0;
9880   }
9881   {
9882     try {
9883       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9884     } catch (std::out_of_range& e) {
9885       {
9886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9887       };
9888     } catch (std::exception& e) {
9889       {
9890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9891       };
9892     } catch (Dali::DaliException e) {
9893       {
9894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9895       };
9896     } catch (...) {
9897       {
9898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9899       };
9900     }
9901   }
9902
9903   jresult = result;
9904   return jresult;
9905 }
9906
9907
9908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9909   void * jresult ;
9910   Dali::Degree arg1 ;
9911   float arg2 ;
9912   float arg3 ;
9913   Dali::Degree *argp1 ;
9914   Dali::Degree result;
9915
9916   argp1 = (Dali::Degree *)jarg1;
9917   if (!argp1) {
9918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9919     return 0;
9920   }
9921   arg1 = *argp1;
9922   arg2 = (float)jarg2;
9923   arg3 = (float)jarg3;
9924   {
9925     try {
9926       result = Dali::Clamp(arg1,arg2,arg3);
9927     } catch (std::out_of_range& e) {
9928       {
9929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9930       };
9931     } catch (std::exception& e) {
9932       {
9933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9934       };
9935     } catch (Dali::DaliException e) {
9936       {
9937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9938       };
9939     } catch (...) {
9940       {
9941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9942       };
9943     }
9944   }
9945
9946   jresult = new Dali::Degree((const Dali::Degree &)result);
9947   return jresult;
9948 }
9949
9950
9951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9952   void * jresult ;
9953   Dali::Radian *result = 0 ;
9954
9955   {
9956     try {
9957       result = (Dali::Radian *)new Dali::Radian();
9958     } catch (std::out_of_range& e) {
9959       {
9960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9961       };
9962     } catch (std::exception& e) {
9963       {
9964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9965       };
9966     } catch (Dali::DaliException e) {
9967       {
9968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9969       };
9970     } catch (...) {
9971       {
9972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9973       };
9974     }
9975   }
9976
9977   jresult = (void *)result;
9978   return jresult;
9979 }
9980
9981
9982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9983   void * jresult ;
9984   float arg1 ;
9985   Dali::Radian *result = 0 ;
9986
9987   arg1 = (float)jarg1;
9988   {
9989     try {
9990       result = (Dali::Radian *)new Dali::Radian(arg1);
9991     } catch (std::out_of_range& e) {
9992       {
9993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9994       };
9995     } catch (std::exception& e) {
9996       {
9997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9998       };
9999     } catch (Dali::DaliException e) {
10000       {
10001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10002       };
10003     } catch (...) {
10004       {
10005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10006       };
10007     }
10008   }
10009
10010   jresult = (void *)result;
10011   return jresult;
10012 }
10013
10014
10015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10016   void * jresult ;
10017   Dali::Degree arg1 ;
10018   Dali::Degree *argp1 ;
10019   Dali::Radian *result = 0 ;
10020
10021   argp1 = (Dali::Degree *)jarg1;
10022   if (!argp1) {
10023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10024     return 0;
10025   }
10026   arg1 = *argp1;
10027   {
10028     try {
10029       result = (Dali::Radian *)new Dali::Radian(arg1);
10030     } catch (std::out_of_range& e) {
10031       {
10032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10033       };
10034     } catch (std::exception& e) {
10035       {
10036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10037       };
10038     } catch (Dali::DaliException e) {
10039       {
10040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10041       };
10042     } catch (...) {
10043       {
10044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10045       };
10046     }
10047   }
10048
10049   jresult = (void *)result;
10050   return jresult;
10051 }
10052
10053
10054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10055   void * jresult ;
10056   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10057   float arg2 ;
10058   Dali::Radian *result = 0 ;
10059
10060   arg1 = (Dali::Radian *)jarg1;
10061   arg2 = (float)jarg2;
10062   {
10063     try {
10064       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10065     } catch (std::out_of_range& e) {
10066       {
10067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10068       };
10069     } catch (std::exception& e) {
10070       {
10071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10072       };
10073     } catch (Dali::DaliException e) {
10074       {
10075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10076       };
10077     } catch (...) {
10078       {
10079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10080       };
10081     }
10082   }
10083
10084   jresult = (void *)result;
10085   return jresult;
10086 }
10087
10088
10089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10090   void * jresult ;
10091   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10092   Dali::Degree arg2 ;
10093   Dali::Degree *argp2 ;
10094   Dali::Radian *result = 0 ;
10095
10096   arg1 = (Dali::Radian *)jarg1;
10097   argp2 = (Dali::Degree *)jarg2;
10098   if (!argp2) {
10099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10100     return 0;
10101   }
10102   arg2 = *argp2;
10103   {
10104     try {
10105       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10106     } catch (std::out_of_range& e) {
10107       {
10108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10109       };
10110     } catch (std::exception& e) {
10111       {
10112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10113       };
10114     } catch (Dali::DaliException e) {
10115       {
10116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10117       };
10118     } catch (...) {
10119       {
10120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10121       };
10122     }
10123   }
10124
10125   jresult = (void *)result;
10126   return jresult;
10127 }
10128
10129
10130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10131   float jresult ;
10132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10133   float result;
10134
10135   arg1 = (Dali::Radian *)jarg1;
10136   {
10137     try {
10138       result = (float)((Dali::Radian const *)arg1)->operator float();
10139     } catch (std::out_of_range& e) {
10140       {
10141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10142       };
10143     } catch (std::exception& e) {
10144       {
10145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10146       };
10147     } catch (Dali::DaliException e) {
10148       {
10149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10150       };
10151     } catch (...) {
10152       {
10153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10154       };
10155     }
10156   }
10157
10158   jresult = result;
10159   return jresult;
10160 }
10161
10162
10163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10164   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10165   float arg2 ;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   arg2 = (float)jarg2;
10169   if (arg1) (arg1)->radian = arg2;
10170 }
10171
10172
10173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10174   float jresult ;
10175   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10176   float result;
10177
10178   arg1 = (Dali::Radian *)jarg1;
10179   result = (float) ((arg1)->radian);
10180   jresult = result;
10181   return jresult;
10182 }
10183
10184
10185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10186   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10187
10188   arg1 = (Dali::Radian *)jarg1;
10189   {
10190     try {
10191       delete arg1;
10192     } catch (std::out_of_range& e) {
10193       {
10194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10195       };
10196     } catch (std::exception& e) {
10197       {
10198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10199       };
10200     } catch (Dali::DaliException e) {
10201       {
10202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10203       };
10204     } catch (...) {
10205       {
10206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10207       };
10208     }
10209   }
10210
10211 }
10212
10213
10214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10215   unsigned int jresult ;
10216   Dali::Radian arg1 ;
10217   Dali::Radian arg2 ;
10218   Dali::Radian *argp1 ;
10219   Dali::Radian *argp2 ;
10220   bool result;
10221
10222   argp1 = (Dali::Radian *)jarg1;
10223   if (!argp1) {
10224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10225     return 0;
10226   }
10227   arg1 = *argp1;
10228   argp2 = (Dali::Radian *)jarg2;
10229   if (!argp2) {
10230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10231     return 0;
10232   }
10233   arg2 = *argp2;
10234   {
10235     try {
10236       result = (bool)Dali::operator ==(arg1,arg2);
10237     } catch (std::out_of_range& e) {
10238       {
10239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10240       };
10241     } catch (std::exception& e) {
10242       {
10243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10244       };
10245     } catch (Dali::DaliException e) {
10246       {
10247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10248       };
10249     } catch (...) {
10250       {
10251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10252       };
10253     }
10254   }
10255
10256   jresult = result;
10257   return jresult;
10258 }
10259
10260
10261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10262   unsigned int jresult ;
10263   Dali::Radian arg1 ;
10264   Dali::Radian arg2 ;
10265   Dali::Radian *argp1 ;
10266   Dali::Radian *argp2 ;
10267   bool result;
10268
10269   argp1 = (Dali::Radian *)jarg1;
10270   if (!argp1) {
10271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10272     return 0;
10273   }
10274   arg1 = *argp1;
10275   argp2 = (Dali::Radian *)jarg2;
10276   if (!argp2) {
10277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10278     return 0;
10279   }
10280   arg2 = *argp2;
10281   {
10282     try {
10283       result = (bool)Dali::operator !=(arg1,arg2);
10284     } catch (std::out_of_range& e) {
10285       {
10286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10287       };
10288     } catch (std::exception& e) {
10289       {
10290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10291       };
10292     } catch (Dali::DaliException e) {
10293       {
10294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10295       };
10296     } catch (...) {
10297       {
10298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10299       };
10300     }
10301   }
10302
10303   jresult = result;
10304   return jresult;
10305 }
10306
10307
10308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10309   unsigned int jresult ;
10310   Dali::Radian arg1 ;
10311   Dali::Degree arg2 ;
10312   Dali::Radian *argp1 ;
10313   Dali::Degree *argp2 ;
10314   bool result;
10315
10316   argp1 = (Dali::Radian *)jarg1;
10317   if (!argp1) {
10318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10319     return 0;
10320   }
10321   arg1 = *argp1;
10322   argp2 = (Dali::Degree *)jarg2;
10323   if (!argp2) {
10324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10325     return 0;
10326   }
10327   arg2 = *argp2;
10328   {
10329     try {
10330       result = (bool)Dali::operator ==(arg1,arg2);
10331     } catch (std::out_of_range& e) {
10332       {
10333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10334       };
10335     } catch (std::exception& e) {
10336       {
10337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10338       };
10339     } catch (Dali::DaliException e) {
10340       {
10341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10342       };
10343     } catch (...) {
10344       {
10345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10346       };
10347     }
10348   }
10349
10350   jresult = result;
10351   return jresult;
10352 }
10353
10354
10355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10356   unsigned int jresult ;
10357   Dali::Radian arg1 ;
10358   Dali::Degree arg2 ;
10359   Dali::Radian *argp1 ;
10360   Dali::Degree *argp2 ;
10361   bool result;
10362
10363   argp1 = (Dali::Radian *)jarg1;
10364   if (!argp1) {
10365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10366     return 0;
10367   }
10368   arg1 = *argp1;
10369   argp2 = (Dali::Degree *)jarg2;
10370   if (!argp2) {
10371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10372     return 0;
10373   }
10374   arg2 = *argp2;
10375   {
10376     try {
10377       result = (bool)Dali::operator !=(arg1,arg2);
10378     } catch (std::out_of_range& e) {
10379       {
10380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10381       };
10382     } catch (std::exception& e) {
10383       {
10384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10385       };
10386     } catch (Dali::DaliException e) {
10387       {
10388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10389       };
10390     } catch (...) {
10391       {
10392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10393       };
10394     }
10395   }
10396
10397   jresult = result;
10398   return jresult;
10399 }
10400
10401
10402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10403   unsigned int jresult ;
10404   Dali::Degree arg1 ;
10405   Dali::Radian arg2 ;
10406   Dali::Degree *argp1 ;
10407   Dali::Radian *argp2 ;
10408   bool result;
10409
10410   argp1 = (Dali::Degree *)jarg1;
10411   if (!argp1) {
10412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10413     return 0;
10414   }
10415   arg1 = *argp1;
10416   argp2 = (Dali::Radian *)jarg2;
10417   if (!argp2) {
10418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10419     return 0;
10420   }
10421   arg2 = *argp2;
10422   {
10423     try {
10424       result = (bool)Dali::operator ==(arg1,arg2);
10425     } catch (std::out_of_range& e) {
10426       {
10427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10428       };
10429     } catch (std::exception& e) {
10430       {
10431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10432       };
10433     } catch (Dali::DaliException e) {
10434       {
10435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10436       };
10437     } catch (...) {
10438       {
10439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10440       };
10441     }
10442   }
10443
10444   jresult = result;
10445   return jresult;
10446 }
10447
10448
10449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10450   unsigned int jresult ;
10451   Dali::Degree arg1 ;
10452   Dali::Radian arg2 ;
10453   Dali::Degree *argp1 ;
10454   Dali::Radian *argp2 ;
10455   bool result;
10456
10457   argp1 = (Dali::Degree *)jarg1;
10458   if (!argp1) {
10459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10460     return 0;
10461   }
10462   arg1 = *argp1;
10463   argp2 = (Dali::Radian *)jarg2;
10464   if (!argp2) {
10465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10466     return 0;
10467   }
10468   arg2 = *argp2;
10469   {
10470     try {
10471       result = (bool)Dali::operator !=(arg1,arg2);
10472     } catch (std::out_of_range& e) {
10473       {
10474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10475       };
10476     } catch (std::exception& e) {
10477       {
10478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10479       };
10480     } catch (Dali::DaliException e) {
10481       {
10482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10483       };
10484     } catch (...) {
10485       {
10486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10487       };
10488     }
10489   }
10490
10491   jresult = result;
10492   return jresult;
10493 }
10494
10495
10496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10497   unsigned int jresult ;
10498   Dali::Radian arg1 ;
10499   Dali::Radian arg2 ;
10500   Dali::Radian *argp1 ;
10501   Dali::Radian *argp2 ;
10502   bool result;
10503
10504   argp1 = (Dali::Radian *)jarg1;
10505   if (!argp1) {
10506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10507     return 0;
10508   }
10509   arg1 = *argp1;
10510   argp2 = (Dali::Radian *)jarg2;
10511   if (!argp2) {
10512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10513     return 0;
10514   }
10515   arg2 = *argp2;
10516   {
10517     try {
10518       result = (bool)Dali::operator >(arg1,arg2);
10519     } catch (std::out_of_range& e) {
10520       {
10521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10522       };
10523     } catch (std::exception& e) {
10524       {
10525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10526       };
10527     } catch (Dali::DaliException e) {
10528       {
10529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10530       };
10531     } catch (...) {
10532       {
10533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10534       };
10535     }
10536   }
10537
10538   jresult = result;
10539   return jresult;
10540 }
10541
10542
10543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10544   unsigned int jresult ;
10545   Dali::Radian arg1 ;
10546   Dali::Degree arg2 ;
10547   Dali::Radian *argp1 ;
10548   Dali::Degree *argp2 ;
10549   bool result;
10550
10551   argp1 = (Dali::Radian *)jarg1;
10552   if (!argp1) {
10553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10554     return 0;
10555   }
10556   arg1 = *argp1;
10557   argp2 = (Dali::Degree *)jarg2;
10558   if (!argp2) {
10559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10560     return 0;
10561   }
10562   arg2 = *argp2;
10563   {
10564     try {
10565       result = (bool)Dali::operator >(arg1,arg2);
10566     } catch (std::out_of_range& e) {
10567       {
10568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10569       };
10570     } catch (std::exception& e) {
10571       {
10572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10573       };
10574     } catch (Dali::DaliException e) {
10575       {
10576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10577       };
10578     } catch (...) {
10579       {
10580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10581       };
10582     }
10583   }
10584
10585   jresult = result;
10586   return jresult;
10587 }
10588
10589
10590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10591   unsigned int jresult ;
10592   Dali::Degree arg1 ;
10593   Dali::Radian arg2 ;
10594   Dali::Degree *argp1 ;
10595   Dali::Radian *argp2 ;
10596   bool result;
10597
10598   argp1 = (Dali::Degree *)jarg1;
10599   if (!argp1) {
10600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10601     return 0;
10602   }
10603   arg1 = *argp1;
10604   argp2 = (Dali::Radian *)jarg2;
10605   if (!argp2) {
10606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10607     return 0;
10608   }
10609   arg2 = *argp2;
10610   {
10611     try {
10612       result = (bool)Dali::operator >(arg1,arg2);
10613     } catch (std::out_of_range& e) {
10614       {
10615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10616       };
10617     } catch (std::exception& e) {
10618       {
10619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10620       };
10621     } catch (Dali::DaliException e) {
10622       {
10623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10624       };
10625     } catch (...) {
10626       {
10627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10628       };
10629     }
10630   }
10631
10632   jresult = result;
10633   return jresult;
10634 }
10635
10636
10637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10638   unsigned int jresult ;
10639   Dali::Radian arg1 ;
10640   Dali::Radian arg2 ;
10641   Dali::Radian *argp1 ;
10642   Dali::Radian *argp2 ;
10643   bool result;
10644
10645   argp1 = (Dali::Radian *)jarg1;
10646   if (!argp1) {
10647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10648     return 0;
10649   }
10650   arg1 = *argp1;
10651   argp2 = (Dali::Radian *)jarg2;
10652   if (!argp2) {
10653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10654     return 0;
10655   }
10656   arg2 = *argp2;
10657   {
10658     try {
10659       result = (bool)Dali::operator <(arg1,arg2);
10660     } catch (std::out_of_range& e) {
10661       {
10662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (std::exception& e) {
10665       {
10666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10667       };
10668     } catch (Dali::DaliException e) {
10669       {
10670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10671       };
10672     } catch (...) {
10673       {
10674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10675       };
10676     }
10677   }
10678
10679   jresult = result;
10680   return jresult;
10681 }
10682
10683
10684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10685   unsigned int jresult ;
10686   Dali::Radian arg1 ;
10687   Dali::Degree arg2 ;
10688   Dali::Radian *argp1 ;
10689   Dali::Degree *argp2 ;
10690   bool result;
10691
10692   argp1 = (Dali::Radian *)jarg1;
10693   if (!argp1) {
10694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10695     return 0;
10696   }
10697   arg1 = *argp1;
10698   argp2 = (Dali::Degree *)jarg2;
10699   if (!argp2) {
10700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10701     return 0;
10702   }
10703   arg2 = *argp2;
10704   {
10705     try {
10706       result = (bool)Dali::operator <(arg1,arg2);
10707     } catch (std::out_of_range& e) {
10708       {
10709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10710       };
10711     } catch (std::exception& e) {
10712       {
10713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10714       };
10715     } catch (Dali::DaliException e) {
10716       {
10717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10718       };
10719     } catch (...) {
10720       {
10721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10722       };
10723     }
10724   }
10725
10726   jresult = result;
10727   return jresult;
10728 }
10729
10730
10731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10732   unsigned int jresult ;
10733   Dali::Degree arg1 ;
10734   Dali::Radian arg2 ;
10735   Dali::Degree *argp1 ;
10736   Dali::Radian *argp2 ;
10737   bool result;
10738
10739   argp1 = (Dali::Degree *)jarg1;
10740   if (!argp1) {
10741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10742     return 0;
10743   }
10744   arg1 = *argp1;
10745   argp2 = (Dali::Radian *)jarg2;
10746   if (!argp2) {
10747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10748     return 0;
10749   }
10750   arg2 = *argp2;
10751   {
10752     try {
10753       result = (bool)Dali::operator <(arg1,arg2);
10754     } catch (std::out_of_range& e) {
10755       {
10756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10757       };
10758     } catch (std::exception& e) {
10759       {
10760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10761       };
10762     } catch (Dali::DaliException e) {
10763       {
10764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10765       };
10766     } catch (...) {
10767       {
10768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10769       };
10770     }
10771   }
10772
10773   jresult = result;
10774   return jresult;
10775 }
10776
10777
10778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10779   void * jresult ;
10780   Dali::Radian arg1 ;
10781   float arg2 ;
10782   Dali::Radian *argp1 ;
10783   Dali::Radian result;
10784
10785   argp1 = (Dali::Radian *)jarg1;
10786   if (!argp1) {
10787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10788     return 0;
10789   }
10790   arg1 = *argp1;
10791   arg2 = (float)jarg2;
10792   {
10793     try {
10794       result = Dali::operator *(arg1,arg2);
10795     } catch (std::out_of_range& e) {
10796       {
10797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10798       };
10799     } catch (std::exception& e) {
10800       {
10801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10802       };
10803     } catch (Dali::DaliException e) {
10804       {
10805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10806       };
10807     } catch (...) {
10808       {
10809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10810       };
10811     }
10812   }
10813
10814   jresult = new Dali::Radian((const Dali::Radian &)result);
10815   return jresult;
10816 }
10817
10818
10819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10820   void * jresult ;
10821   Dali::Radian arg1 ;
10822   Dali::Radian *argp1 ;
10823   Dali::Radian result;
10824
10825   argp1 = (Dali::Radian *)jarg1;
10826   if (!argp1) {
10827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10828     return 0;
10829   }
10830   arg1 = *argp1;
10831   {
10832     try {
10833       result = Dali::operator -(arg1);
10834     } catch (std::out_of_range& e) {
10835       {
10836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10837       };
10838     } catch (std::exception& e) {
10839       {
10840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10841       };
10842     } catch (Dali::DaliException e) {
10843       {
10844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10845       };
10846     } catch (...) {
10847       {
10848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10849       };
10850     }
10851   }
10852
10853   jresult = new Dali::Radian((const Dali::Radian &)result);
10854   return jresult;
10855 }
10856
10857
10858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10859   void * jresult ;
10860   Dali::Radian arg1 ;
10861   float arg2 ;
10862   float arg3 ;
10863   Dali::Radian *argp1 ;
10864   Dali::Radian result;
10865
10866   argp1 = (Dali::Radian *)jarg1;
10867   if (!argp1) {
10868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10869     return 0;
10870   }
10871   arg1 = *argp1;
10872   arg2 = (float)jarg2;
10873   arg3 = (float)jarg3;
10874   {
10875     try {
10876       result = Dali::Clamp(arg1,arg2,arg3);
10877     } catch (std::out_of_range& e) {
10878       {
10879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10880       };
10881     } catch (std::exception& e) {
10882       {
10883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10884       };
10885     } catch (Dali::DaliException e) {
10886       {
10887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10888       };
10889     } catch (...) {
10890       {
10891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10892       };
10893     }
10894   }
10895
10896   jresult = new Dali::Radian((const Dali::Radian &)result);
10897   return jresult;
10898 }
10899
10900
10901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10902   void * jresult ;
10903   Dali::Quaternion *result = 0 ;
10904
10905   {
10906     try {
10907       result = (Dali::Quaternion *)new Dali::Quaternion();
10908     } catch (std::out_of_range& e) {
10909       {
10910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10911       };
10912     } catch (std::exception& e) {
10913       {
10914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10915       };
10916     } catch (Dali::DaliException e) {
10917       {
10918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10919       };
10920     } catch (...) {
10921       {
10922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10923       };
10924     }
10925   }
10926
10927   jresult = (void *)result;
10928   return jresult;
10929 }
10930
10931
10932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10933   void * jresult ;
10934   Dali::Radian arg1 ;
10935   Dali::Vector3 *arg2 = 0 ;
10936   Dali::Radian *argp1 ;
10937   Dali::Quaternion *result = 0 ;
10938
10939   argp1 = (Dali::Radian *)jarg1;
10940   if (!argp1) {
10941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10942     return 0;
10943   }
10944   arg1 = *argp1;
10945   arg2 = (Dali::Vector3 *)jarg2;
10946   if (!arg2) {
10947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10948     return 0;
10949   }
10950   {
10951     try {
10952       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10953     } catch (std::out_of_range& e) {
10954       {
10955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10956       };
10957     } catch (std::exception& e) {
10958       {
10959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10960       };
10961     } catch (Dali::DaliException e) {
10962       {
10963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10964       };
10965     } catch (...) {
10966       {
10967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10968       };
10969     }
10970   }
10971
10972   jresult = (void *)result;
10973   return jresult;
10974 }
10975
10976
10977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10978   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10979
10980   arg1 = (Dali::Quaternion *)jarg1;
10981   {
10982     try {
10983       delete arg1;
10984     } catch (std::out_of_range& e) {
10985       {
10986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10987       };
10988     } catch (std::exception& e) {
10989       {
10990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10991       };
10992     } catch (Dali::DaliException e) {
10993       {
10994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10995       };
10996     } catch (...) {
10997       {
10998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10999       };
11000     }
11001   }
11002
11003 }
11004
11005
11006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11007   void * jresult ;
11008   Dali::Quaternion *result = 0 ;
11009
11010   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11011   jresult = (void *)result;
11012   return jresult;
11013 }
11014
11015
11016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11017   unsigned int jresult ;
11018   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11019   bool result;
11020
11021   arg1 = (Dali::Quaternion *)jarg1;
11022   {
11023     try {
11024       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11025     } catch (std::out_of_range& e) {
11026       {
11027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11028       };
11029     } catch (std::exception& e) {
11030       {
11031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11032       };
11033     } catch (Dali::DaliException e) {
11034       {
11035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11036       };
11037     } catch (...) {
11038       {
11039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11040       };
11041     }
11042   }
11043
11044   jresult = result;
11045   return jresult;
11046 }
11047
11048
11049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11050   unsigned int jresult ;
11051   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11052   Dali::Vector3 *arg2 = 0 ;
11053   Dali::Radian *arg3 = 0 ;
11054   bool result;
11055
11056   arg1 = (Dali::Quaternion *)jarg1;
11057   arg2 = (Dali::Vector3 *)jarg2;
11058   if (!arg2) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11060     return 0;
11061   }
11062   arg3 = (Dali::Radian *)jarg3;
11063   if (!arg3) {
11064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11065     return 0;
11066   }
11067   {
11068     try {
11069       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11070     } catch (std::out_of_range& e) {
11071       {
11072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11073       };
11074     } catch (std::exception& e) {
11075       {
11076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11077       };
11078     } catch (Dali::DaliException e) {
11079       {
11080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11081       };
11082     } catch (...) {
11083       {
11084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11085       };
11086     }
11087   }
11088
11089   jresult = result;
11090   return jresult;
11091 }
11092
11093
11094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11095   void * jresult ;
11096   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11097   Dali::Quaternion *arg2 = 0 ;
11098   Dali::Quaternion result;
11099
11100   arg1 = (Dali::Quaternion *)jarg1;
11101   arg2 = (Dali::Quaternion *)jarg2;
11102   if (!arg2) {
11103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11104     return 0;
11105   }
11106   {
11107     try {
11108       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11109     } catch (std::out_of_range& e) {
11110       {
11111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11112       };
11113     } catch (std::exception& e) {
11114       {
11115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11116       };
11117     } catch (Dali::DaliException e) {
11118       {
11119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11120       };
11121     } catch (...) {
11122       {
11123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11124       };
11125     }
11126   }
11127
11128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11129   return jresult;
11130 }
11131
11132
11133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11134   void * jresult ;
11135   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11136   Dali::Quaternion *arg2 = 0 ;
11137   Dali::Quaternion result;
11138
11139   arg1 = (Dali::Quaternion *)jarg1;
11140   arg2 = (Dali::Quaternion *)jarg2;
11141   if (!arg2) {
11142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11143     return 0;
11144   }
11145   {
11146     try {
11147       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11148     } catch (std::out_of_range& e) {
11149       {
11150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11151       };
11152     } catch (std::exception& e) {
11153       {
11154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11155       };
11156     } catch (Dali::DaliException e) {
11157       {
11158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11159       };
11160     } catch (...) {
11161       {
11162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11163       };
11164     }
11165   }
11166
11167   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11168   return jresult;
11169 }
11170
11171
11172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11173   void * jresult ;
11174   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11175   Dali::Quaternion *arg2 = 0 ;
11176   Dali::Quaternion result;
11177
11178   arg1 = (Dali::Quaternion *)jarg1;
11179   arg2 = (Dali::Quaternion *)jarg2;
11180   if (!arg2) {
11181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11182     return 0;
11183   }
11184   {
11185     try {
11186       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11187     } catch (std::out_of_range& e) {
11188       {
11189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11190       };
11191     } catch (std::exception& e) {
11192       {
11193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11194       };
11195     } catch (Dali::DaliException e) {
11196       {
11197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11198       };
11199     } catch (...) {
11200       {
11201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11202       };
11203     }
11204   }
11205
11206   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11207   return jresult;
11208 }
11209
11210
11211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11212   void * jresult ;
11213   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11214   Dali::Vector3 *arg2 = 0 ;
11215   Dali::Vector3 result;
11216
11217   arg1 = (Dali::Quaternion *)jarg1;
11218   arg2 = (Dali::Vector3 *)jarg2;
11219   if (!arg2) {
11220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11221     return 0;
11222   }
11223   {
11224     try {
11225       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11226     } catch (std::out_of_range& e) {
11227       {
11228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11229       };
11230     } catch (std::exception& e) {
11231       {
11232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11233       };
11234     } catch (Dali::DaliException e) {
11235       {
11236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11237       };
11238     } catch (...) {
11239       {
11240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11241       };
11242     }
11243   }
11244
11245   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11246   return jresult;
11247 }
11248
11249
11250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11251   void * jresult ;
11252   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11253   Dali::Quaternion *arg2 = 0 ;
11254   Dali::Quaternion result;
11255
11256   arg1 = (Dali::Quaternion *)jarg1;
11257   arg2 = (Dali::Quaternion *)jarg2;
11258   if (!arg2) {
11259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11260     return 0;
11261   }
11262   {
11263     try {
11264       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11265     } catch (std::out_of_range& e) {
11266       {
11267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11268       };
11269     } catch (std::exception& e) {
11270       {
11271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11272       };
11273     } catch (Dali::DaliException e) {
11274       {
11275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11276       };
11277     } catch (...) {
11278       {
11279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11280       };
11281     }
11282   }
11283
11284   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11285   return jresult;
11286 }
11287
11288
11289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11290   void * jresult ;
11291   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11292   float arg2 ;
11293   Dali::Quaternion result;
11294
11295   arg1 = (Dali::Quaternion *)jarg1;
11296   arg2 = (float)jarg2;
11297   {
11298     try {
11299       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11300     } catch (std::out_of_range& e) {
11301       {
11302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11303       };
11304     } catch (std::exception& e) {
11305       {
11306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11307       };
11308     } catch (Dali::DaliException e) {
11309       {
11310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11311       };
11312     } catch (...) {
11313       {
11314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11315       };
11316     }
11317   }
11318
11319   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11320   return jresult;
11321 }
11322
11323
11324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11325   void * jresult ;
11326   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11327   float arg2 ;
11328   Dali::Quaternion result;
11329
11330   arg1 = (Dali::Quaternion *)jarg1;
11331   arg2 = (float)jarg2;
11332   {
11333     try {
11334       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11335     } catch (std::out_of_range& e) {
11336       {
11337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11338       };
11339     } catch (std::exception& e) {
11340       {
11341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11342       };
11343     } catch (Dali::DaliException e) {
11344       {
11345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11346       };
11347     } catch (...) {
11348       {
11349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11350       };
11351     }
11352   }
11353
11354   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11355   return jresult;
11356 }
11357
11358
11359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11360   void * jresult ;
11361   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11362   Dali::Quaternion result;
11363
11364   arg1 = (Dali::Quaternion *)jarg1;
11365   {
11366     try {
11367       result = ((Dali::Quaternion const *)arg1)->operator -();
11368     } catch (std::out_of_range& e) {
11369       {
11370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11371       };
11372     } catch (std::exception& e) {
11373       {
11374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11375       };
11376     } catch (Dali::DaliException e) {
11377       {
11378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11379       };
11380     } catch (...) {
11381       {
11382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11383       };
11384     }
11385   }
11386
11387   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11388   return jresult;
11389 }
11390
11391
11392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11393   void * jresult ;
11394   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11395   Dali::Quaternion *arg2 = 0 ;
11396   Dali::Quaternion *result = 0 ;
11397
11398   arg1 = (Dali::Quaternion *)jarg1;
11399   arg2 = (Dali::Quaternion *)jarg2;
11400   if (!arg2) {
11401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11402     return 0;
11403   }
11404   {
11405     try {
11406       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11407     } catch (std::out_of_range& e) {
11408       {
11409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11410       };
11411     } catch (std::exception& e) {
11412       {
11413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11414       };
11415     } catch (Dali::DaliException e) {
11416       {
11417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11418       };
11419     } catch (...) {
11420       {
11421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11422       };
11423     }
11424   }
11425
11426   jresult = (void *)result;
11427   return jresult;
11428 }
11429
11430
11431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11432   void * jresult ;
11433   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11434   Dali::Quaternion *arg2 = 0 ;
11435   Dali::Quaternion *result = 0 ;
11436
11437   arg1 = (Dali::Quaternion *)jarg1;
11438   arg2 = (Dali::Quaternion *)jarg2;
11439   if (!arg2) {
11440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11441     return 0;
11442   }
11443   {
11444     try {
11445       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11446     } catch (std::out_of_range& e) {
11447       {
11448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11449       };
11450     } catch (std::exception& e) {
11451       {
11452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11453       };
11454     } catch (Dali::DaliException e) {
11455       {
11456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11457       };
11458     } catch (...) {
11459       {
11460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11461       };
11462     }
11463   }
11464
11465   jresult = (void *)result;
11466   return jresult;
11467 }
11468
11469
11470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11471   void * jresult ;
11472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11473   Dali::Quaternion *arg2 = 0 ;
11474   Dali::Quaternion *result = 0 ;
11475
11476   arg1 = (Dali::Quaternion *)jarg1;
11477   arg2 = (Dali::Quaternion *)jarg2;
11478   if (!arg2) {
11479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11480     return 0;
11481   }
11482   {
11483     try {
11484       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11485     } catch (std::out_of_range& e) {
11486       {
11487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11488       };
11489     } catch (std::exception& e) {
11490       {
11491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11492       };
11493     } catch (Dali::DaliException e) {
11494       {
11495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11496       };
11497     } catch (...) {
11498       {
11499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11500       };
11501     }
11502   }
11503
11504   jresult = (void *)result;
11505   return jresult;
11506 }
11507
11508
11509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11510   void * jresult ;
11511   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11512   float arg2 ;
11513   Dali::Quaternion *result = 0 ;
11514
11515   arg1 = (Dali::Quaternion *)jarg1;
11516   arg2 = (float)jarg2;
11517   {
11518     try {
11519       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11520     } catch (std::out_of_range& e) {
11521       {
11522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11523       };
11524     } catch (std::exception& e) {
11525       {
11526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11527       };
11528     } catch (Dali::DaliException e) {
11529       {
11530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11531       };
11532     } catch (...) {
11533       {
11534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11535       };
11536     }
11537   }
11538
11539   jresult = (void *)result;
11540   return jresult;
11541 }
11542
11543
11544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11545   void * jresult ;
11546   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11547   float arg2 ;
11548   Dali::Quaternion *result = 0 ;
11549
11550   arg1 = (Dali::Quaternion *)jarg1;
11551   arg2 = (float)jarg2;
11552   {
11553     try {
11554       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11555     } catch (std::out_of_range& e) {
11556       {
11557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (std::exception& e) {
11560       {
11561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11562       };
11563     } catch (Dali::DaliException e) {
11564       {
11565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11566       };
11567     } catch (...) {
11568       {
11569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11570       };
11571     }
11572   }
11573
11574   jresult = (void *)result;
11575   return jresult;
11576 }
11577
11578
11579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11580   unsigned int jresult ;
11581   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11582   Dali::Quaternion *arg2 = 0 ;
11583   bool result;
11584
11585   arg1 = (Dali::Quaternion *)jarg1;
11586   arg2 = (Dali::Quaternion *)jarg2;
11587   if (!arg2) {
11588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11589     return 0;
11590   }
11591   {
11592     try {
11593       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11594     } catch (std::out_of_range& e) {
11595       {
11596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11597       };
11598     } catch (std::exception& e) {
11599       {
11600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11601       };
11602     } catch (Dali::DaliException e) {
11603       {
11604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11605       };
11606     } catch (...) {
11607       {
11608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11609       };
11610     }
11611   }
11612
11613   jresult = result;
11614   return jresult;
11615 }
11616
11617
11618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11619   unsigned int jresult ;
11620   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11621   Dali::Quaternion *arg2 = 0 ;
11622   bool result;
11623
11624   arg1 = (Dali::Quaternion *)jarg1;
11625   arg2 = (Dali::Quaternion *)jarg2;
11626   if (!arg2) {
11627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11628     return 0;
11629   }
11630   {
11631     try {
11632       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11633     } catch (std::out_of_range& e) {
11634       {
11635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11636       };
11637     } catch (std::exception& e) {
11638       {
11639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11640       };
11641     } catch (Dali::DaliException e) {
11642       {
11643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11644       };
11645     } catch (...) {
11646       {
11647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11648       };
11649     }
11650   }
11651
11652   jresult = result;
11653   return jresult;
11654 }
11655
11656
11657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11658   float jresult ;
11659   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11660   float result;
11661
11662   arg1 = (Dali::Quaternion *)jarg1;
11663   {
11664     try {
11665       result = (float)((Dali::Quaternion const *)arg1)->Length();
11666     } catch (std::out_of_range& e) {
11667       {
11668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11669       };
11670     } catch (std::exception& e) {
11671       {
11672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (Dali::DaliException e) {
11675       {
11676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11677       };
11678     } catch (...) {
11679       {
11680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11681       };
11682     }
11683   }
11684
11685   jresult = result;
11686   return jresult;
11687 }
11688
11689
11690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11691   float jresult ;
11692   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11693   float result;
11694
11695   arg1 = (Dali::Quaternion *)jarg1;
11696   {
11697     try {
11698       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11699     } catch (std::out_of_range& e) {
11700       {
11701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11702       };
11703     } catch (std::exception& e) {
11704       {
11705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11706       };
11707     } catch (Dali::DaliException e) {
11708       {
11709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11710       };
11711     } catch (...) {
11712       {
11713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11714       };
11715     }
11716   }
11717
11718   jresult = result;
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11724   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11725
11726   arg1 = (Dali::Quaternion *)jarg1;
11727   {
11728     try {
11729       (arg1)->Normalize();
11730     } catch (std::out_of_range& e) {
11731       {
11732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11733       };
11734     } catch (std::exception& e) {
11735       {
11736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11737       };
11738     } catch (Dali::DaliException e) {
11739       {
11740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11741       };
11742     } catch (...) {
11743       {
11744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11745       };
11746     }
11747   }
11748
11749 }
11750
11751
11752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11753   void * jresult ;
11754   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11755   Dali::Quaternion result;
11756
11757   arg1 = (Dali::Quaternion *)jarg1;
11758   {
11759     try {
11760       result = ((Dali::Quaternion const *)arg1)->Normalized();
11761     } catch (std::out_of_range& e) {
11762       {
11763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11764       };
11765     } catch (std::exception& e) {
11766       {
11767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11768       };
11769     } catch (Dali::DaliException e) {
11770       {
11771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11772       };
11773     } catch (...) {
11774       {
11775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11776       };
11777     }
11778   }
11779
11780   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11781   return jresult;
11782 }
11783
11784
11785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11786   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11787
11788   arg1 = (Dali::Quaternion *)jarg1;
11789   {
11790     try {
11791       (arg1)->Conjugate();
11792     } catch (std::out_of_range& e) {
11793       {
11794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11795       };
11796     } catch (std::exception& e) {
11797       {
11798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11799       };
11800     } catch (Dali::DaliException e) {
11801       {
11802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11803       };
11804     } catch (...) {
11805       {
11806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11807       };
11808     }
11809   }
11810
11811 }
11812
11813
11814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11815   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11816
11817   arg1 = (Dali::Quaternion *)jarg1;
11818   {
11819     try {
11820       (arg1)->Invert();
11821     } catch (std::out_of_range& e) {
11822       {
11823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11824       };
11825     } catch (std::exception& e) {
11826       {
11827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11828       };
11829     } catch (Dali::DaliException e) {
11830       {
11831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11832       };
11833     } catch (...) {
11834       {
11835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11836       };
11837     }
11838   }
11839
11840 }
11841
11842
11843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11844   void * jresult ;
11845   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11846   Dali::Quaternion result;
11847
11848   arg1 = (Dali::Quaternion *)jarg1;
11849   {
11850     try {
11851       result = ((Dali::Quaternion const *)arg1)->Log();
11852     } catch (std::out_of_range& e) {
11853       {
11854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11855       };
11856     } catch (std::exception& e) {
11857       {
11858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11859       };
11860     } catch (Dali::DaliException e) {
11861       {
11862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11863       };
11864     } catch (...) {
11865       {
11866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11867       };
11868     }
11869   }
11870
11871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11872   return jresult;
11873 }
11874
11875
11876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11877   void * jresult ;
11878   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11879   Dali::Quaternion result;
11880
11881   arg1 = (Dali::Quaternion *)jarg1;
11882   {
11883     try {
11884       result = ((Dali::Quaternion const *)arg1)->Exp();
11885     } catch (std::out_of_range& e) {
11886       {
11887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11888       };
11889     } catch (std::exception& e) {
11890       {
11891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11892       };
11893     } catch (Dali::DaliException e) {
11894       {
11895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11896       };
11897     } catch (...) {
11898       {
11899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11900       };
11901     }
11902   }
11903
11904   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11905   return jresult;
11906 }
11907
11908
11909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11910   float jresult ;
11911   Dali::Quaternion *arg1 = 0 ;
11912   Dali::Quaternion *arg2 = 0 ;
11913   float result;
11914
11915   arg1 = (Dali::Quaternion *)jarg1;
11916   if (!arg1) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   arg2 = (Dali::Quaternion *)jarg2;
11921   if (!arg2) {
11922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11923     return 0;
11924   }
11925   {
11926     try {
11927       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11928     } catch (std::out_of_range& e) {
11929       {
11930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11931       };
11932     } catch (std::exception& e) {
11933       {
11934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11935       };
11936     } catch (Dali::DaliException e) {
11937       {
11938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11939       };
11940     } catch (...) {
11941       {
11942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11943       };
11944     }
11945   }
11946
11947   jresult = result;
11948   return jresult;
11949 }
11950
11951
11952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11953   void * jresult ;
11954   Dali::Quaternion *arg1 = 0 ;
11955   Dali::Quaternion *arg2 = 0 ;
11956   float arg3 ;
11957   Dali::Quaternion result;
11958
11959   arg1 = (Dali::Quaternion *)jarg1;
11960   if (!arg1) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg2 = (Dali::Quaternion *)jarg2;
11965   if (!arg2) {
11966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11967     return 0;
11968   }
11969   arg3 = (float)jarg3;
11970   {
11971     try {
11972       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11973     } catch (std::out_of_range& e) {
11974       {
11975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11976       };
11977     } catch (std::exception& e) {
11978       {
11979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11980       };
11981     } catch (Dali::DaliException e) {
11982       {
11983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11984       };
11985     } catch (...) {
11986       {
11987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11988       };
11989     }
11990   }
11991
11992   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11993   return jresult;
11994 }
11995
11996
11997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11998   void * jresult ;
11999   Dali::Quaternion *arg1 = 0 ;
12000   Dali::Quaternion *arg2 = 0 ;
12001   float arg3 ;
12002   Dali::Quaternion result;
12003
12004   arg1 = (Dali::Quaternion *)jarg1;
12005   if (!arg1) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg2 = (Dali::Quaternion *)jarg2;
12010   if (!arg2) {
12011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12012     return 0;
12013   }
12014   arg3 = (float)jarg3;
12015   {
12016     try {
12017       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12018     } catch (std::out_of_range& e) {
12019       {
12020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12021       };
12022     } catch (std::exception& e) {
12023       {
12024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12025       };
12026     } catch (Dali::DaliException e) {
12027       {
12028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12029       };
12030     } catch (...) {
12031       {
12032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12033       };
12034     }
12035   }
12036
12037   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12038   return jresult;
12039 }
12040
12041
12042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12043   void * jresult ;
12044   Dali::Quaternion *arg1 = 0 ;
12045   Dali::Quaternion *arg2 = 0 ;
12046   float arg3 ;
12047   Dali::Quaternion result;
12048
12049   arg1 = (Dali::Quaternion *)jarg1;
12050   if (!arg1) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg2 = (Dali::Quaternion *)jarg2;
12055   if (!arg2) {
12056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12057     return 0;
12058   }
12059   arg3 = (float)jarg3;
12060   {
12061     try {
12062       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12063     } catch (std::out_of_range& e) {
12064       {
12065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12066       };
12067     } catch (std::exception& e) {
12068       {
12069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12070       };
12071     } catch (Dali::DaliException e) {
12072       {
12073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12074       };
12075     } catch (...) {
12076       {
12077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12078       };
12079     }
12080   }
12081
12082   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12083   return jresult;
12084 }
12085
12086
12087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12088   void * jresult ;
12089   Dali::Quaternion *arg1 = 0 ;
12090   Dali::Quaternion *arg2 = 0 ;
12091   Dali::Quaternion *arg3 = 0 ;
12092   Dali::Quaternion *arg4 = 0 ;
12093   float arg5 ;
12094   Dali::Quaternion result;
12095
12096   arg1 = (Dali::Quaternion *)jarg1;
12097   if (!arg1) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg2 = (Dali::Quaternion *)jarg2;
12102   if (!arg2) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg3 = (Dali::Quaternion *)jarg3;
12107   if (!arg3) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg4 = (Dali::Quaternion *)jarg4;
12112   if (!arg4) {
12113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12114     return 0;
12115   }
12116   arg5 = (float)jarg5;
12117   {
12118     try {
12119       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12120     } catch (std::out_of_range& e) {
12121       {
12122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12123       };
12124     } catch (std::exception& e) {
12125       {
12126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12127       };
12128     } catch (Dali::DaliException e) {
12129       {
12130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12131       };
12132     } catch (...) {
12133       {
12134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12135       };
12136     }
12137   }
12138
12139   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12140   return jresult;
12141 }
12142
12143
12144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12145   float jresult ;
12146   Dali::Quaternion *arg1 = 0 ;
12147   Dali::Quaternion *arg2 = 0 ;
12148   float result;
12149
12150   arg1 = (Dali::Quaternion *)jarg1;
12151   if (!arg1) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   arg2 = (Dali::Quaternion *)jarg2;
12156   if (!arg2) {
12157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12158     return 0;
12159   }
12160   {
12161     try {
12162       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12163     } catch (std::out_of_range& e) {
12164       {
12165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12166       };
12167     } catch (std::exception& e) {
12168       {
12169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12170       };
12171     } catch (Dali::DaliException e) {
12172       {
12173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12174       };
12175     } catch (...) {
12176       {
12177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12178       };
12179     }
12180   }
12181
12182   jresult = result;
12183   return jresult;
12184 }
12185
12186
12187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12188   void * jresult ;
12189   Dali::Matrix *result = 0 ;
12190
12191   {
12192     try {
12193       result = (Dali::Matrix *)new Dali::Matrix();
12194     } catch (std::out_of_range& e) {
12195       {
12196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12197       };
12198     } catch (std::exception& e) {
12199       {
12200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12201       };
12202     } catch (Dali::DaliException e) {
12203       {
12204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12205       };
12206     } catch (...) {
12207       {
12208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12209       };
12210     }
12211   }
12212
12213   jresult = (void *)result;
12214   return jresult;
12215 }
12216
12217
12218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12219   void * jresult ;
12220   bool arg1 ;
12221   Dali::Matrix *result = 0 ;
12222
12223   arg1 = jarg1 ? true : false;
12224   {
12225     try {
12226       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12227     } catch (std::out_of_range& e) {
12228       {
12229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12230       };
12231     } catch (std::exception& e) {
12232       {
12233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12234       };
12235     } catch (Dali::DaliException e) {
12236       {
12237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12238       };
12239     } catch (...) {
12240       {
12241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12242       };
12243     }
12244   }
12245
12246   jresult = (void *)result;
12247   return jresult;
12248 }
12249
12250
12251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12252   void * jresult ;
12253   float *arg1 = (float *) 0 ;
12254   Dali::Matrix *result = 0 ;
12255
12256   arg1 = jarg1;
12257   {
12258     try {
12259       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12260     } catch (std::out_of_range& e) {
12261       {
12262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12263       };
12264     } catch (std::exception& e) {
12265       {
12266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12267       };
12268     } catch (Dali::DaliException e) {
12269       {
12270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12271       };
12272     } catch (...) {
12273       {
12274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12275       };
12276     }
12277   }
12278
12279   jresult = (void *)result;
12280
12281
12282   return jresult;
12283 }
12284
12285
12286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12287   void * jresult ;
12288   Dali::Quaternion *arg1 = 0 ;
12289   Dali::Matrix *result = 0 ;
12290
12291   arg1 = (Dali::Quaternion *)jarg1;
12292   if (!arg1) {
12293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12294     return 0;
12295   }
12296   {
12297     try {
12298       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12299     } catch (std::out_of_range& e) {
12300       {
12301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12302       };
12303     } catch (std::exception& e) {
12304       {
12305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12306       };
12307     } catch (Dali::DaliException e) {
12308       {
12309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12310       };
12311     } catch (...) {
12312       {
12313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12314       };
12315     }
12316   }
12317
12318   jresult = (void *)result;
12319   return jresult;
12320 }
12321
12322
12323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12324   void * jresult ;
12325   Dali::Matrix *arg1 = 0 ;
12326   Dali::Matrix *result = 0 ;
12327
12328   arg1 = (Dali::Matrix *)jarg1;
12329   if (!arg1) {
12330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12331     return 0;
12332   }
12333   {
12334     try {
12335       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12336     } catch (std::out_of_range& e) {
12337       {
12338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12339       };
12340     } catch (std::exception& e) {
12341       {
12342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12343       };
12344     } catch (Dali::DaliException e) {
12345       {
12346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12347       };
12348     } catch (...) {
12349       {
12350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12351       };
12352     }
12353   }
12354
12355   jresult = (void *)result;
12356   return jresult;
12357 }
12358
12359
12360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12361   void * jresult ;
12362   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12363   Dali::Matrix *arg2 = 0 ;
12364   Dali::Matrix *result = 0 ;
12365
12366   arg1 = (Dali::Matrix *)jarg1;
12367   arg2 = (Dali::Matrix *)jarg2;
12368   if (!arg2) {
12369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12370     return 0;
12371   }
12372   {
12373     try {
12374       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12375     } catch (std::out_of_range& e) {
12376       {
12377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12378       };
12379     } catch (std::exception& e) {
12380       {
12381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12382       };
12383     } catch (Dali::DaliException e) {
12384       {
12385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12386       };
12387     } catch (...) {
12388       {
12389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12390       };
12391     }
12392   }
12393
12394   jresult = (void *)result;
12395   return jresult;
12396 }
12397
12398
12399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12400   void * jresult ;
12401   Dali::Matrix *result = 0 ;
12402
12403   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12404   jresult = (void *)result;
12405   return jresult;
12406 }
12407
12408
12409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12410   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12411
12412   arg1 = (Dali::Matrix *)jarg1;
12413   {
12414     try {
12415       (arg1)->SetIdentity();
12416     } catch (std::out_of_range& e) {
12417       {
12418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12419       };
12420     } catch (std::exception& e) {
12421       {
12422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12423       };
12424     } catch (Dali::DaliException e) {
12425       {
12426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12427       };
12428     } catch (...) {
12429       {
12430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12431       };
12432     }
12433   }
12434
12435 }
12436
12437
12438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12439   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12440   Dali::Vector3 *arg2 = 0 ;
12441
12442   arg1 = (Dali::Matrix *)jarg1;
12443   arg2 = (Dali::Vector3 *)jarg2;
12444   if (!arg2) {
12445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12446     return ;
12447   }
12448   {
12449     try {
12450       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12451     } catch (std::out_of_range& e) {
12452       {
12453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12454       };
12455     } catch (std::exception& e) {
12456       {
12457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12458       };
12459     } catch (Dali::DaliException e) {
12460       {
12461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12462       };
12463     } catch (...) {
12464       {
12465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12466       };
12467     }
12468   }
12469
12470 }
12471
12472
12473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12474   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12475   Dali::Matrix *arg2 = 0 ;
12476
12477   arg1 = (Dali::Matrix *)jarg1;
12478   arg2 = (Dali::Matrix *)jarg2;
12479   if (!arg2) {
12480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12481     return ;
12482   }
12483   {
12484     try {
12485       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12486     } catch (std::out_of_range& e) {
12487       {
12488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12489       };
12490     } catch (std::exception& e) {
12491       {
12492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12493       };
12494     } catch (Dali::DaliException e) {
12495       {
12496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12497       };
12498     } catch (...) {
12499       {
12500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12501       };
12502     }
12503   }
12504
12505 }
12506
12507
12508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12509   unsigned int jresult ;
12510   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12511   bool result;
12512
12513   arg1 = (Dali::Matrix *)jarg1;
12514   {
12515     try {
12516       result = (bool)(arg1)->Invert();
12517     } catch (std::out_of_range& e) {
12518       {
12519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12520       };
12521     } catch (std::exception& e) {
12522       {
12523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12524       };
12525     } catch (Dali::DaliException e) {
12526       {
12527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12528       };
12529     } catch (...) {
12530       {
12531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12532       };
12533     }
12534   }
12535
12536   jresult = result;
12537   return jresult;
12538 }
12539
12540
12541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12542   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12543
12544   arg1 = (Dali::Matrix *)jarg1;
12545   {
12546     try {
12547       (arg1)->Transpose();
12548     } catch (std::out_of_range& e) {
12549       {
12550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12551       };
12552     } catch (std::exception& e) {
12553       {
12554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12555       };
12556     } catch (Dali::DaliException e) {
12557       {
12558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12559       };
12560     } catch (...) {
12561       {
12562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12563       };
12564     }
12565   }
12566
12567 }
12568
12569
12570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12571   void * jresult ;
12572   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12573   Dali::Vector3 result;
12574
12575   arg1 = (Dali::Matrix *)jarg1;
12576   {
12577     try {
12578       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12579     } catch (std::out_of_range& e) {
12580       {
12581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12582       };
12583     } catch (std::exception& e) {
12584       {
12585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12586       };
12587     } catch (Dali::DaliException e) {
12588       {
12589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12590       };
12591     } catch (...) {
12592       {
12593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12594       };
12595     }
12596   }
12597
12598   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12599   return jresult;
12600 }
12601
12602
12603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12604   void * jresult ;
12605   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12606   Dali::Vector3 result;
12607
12608   arg1 = (Dali::Matrix *)jarg1;
12609   {
12610     try {
12611       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12612     } catch (std::out_of_range& e) {
12613       {
12614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12615       };
12616     } catch (std::exception& e) {
12617       {
12618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12619       };
12620     } catch (Dali::DaliException e) {
12621       {
12622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12623       };
12624     } catch (...) {
12625       {
12626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12627       };
12628     }
12629   }
12630
12631   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12632   return jresult;
12633 }
12634
12635
12636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12637   void * jresult ;
12638   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12639   Dali::Vector3 result;
12640
12641   arg1 = (Dali::Matrix *)jarg1;
12642   {
12643     try {
12644       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12645     } catch (std::out_of_range& e) {
12646       {
12647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12648       };
12649     } catch (std::exception& e) {
12650       {
12651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12652       };
12653     } catch (Dali::DaliException e) {
12654       {
12655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12656       };
12657     } catch (...) {
12658       {
12659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12660       };
12661     }
12662   }
12663
12664   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12665   return jresult;
12666 }
12667
12668
12669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12670   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12671   Dali::Vector3 *arg2 = 0 ;
12672
12673   arg1 = (Dali::Matrix *)jarg1;
12674   arg2 = (Dali::Vector3 *)jarg2;
12675   if (!arg2) {
12676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12677     return ;
12678   }
12679   {
12680     try {
12681       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12682     } catch (std::out_of_range& e) {
12683       {
12684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12685       };
12686     } catch (std::exception& e) {
12687       {
12688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12689       };
12690     } catch (Dali::DaliException e) {
12691       {
12692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12693       };
12694     } catch (...) {
12695       {
12696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12697       };
12698     }
12699   }
12700
12701 }
12702
12703
12704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12705   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12706   Dali::Vector3 *arg2 = 0 ;
12707
12708   arg1 = (Dali::Matrix *)jarg1;
12709   arg2 = (Dali::Vector3 *)jarg2;
12710   if (!arg2) {
12711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12712     return ;
12713   }
12714   {
12715     try {
12716       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12717     } catch (std::out_of_range& e) {
12718       {
12719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12720       };
12721     } catch (std::exception& e) {
12722       {
12723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12724       };
12725     } catch (Dali::DaliException e) {
12726       {
12727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12728       };
12729     } catch (...) {
12730       {
12731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12732       };
12733     }
12734   }
12735
12736 }
12737
12738
12739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12740   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12741   Dali::Vector3 *arg2 = 0 ;
12742
12743   arg1 = (Dali::Matrix *)jarg1;
12744   arg2 = (Dali::Vector3 *)jarg2;
12745   if (!arg2) {
12746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12747     return ;
12748   }
12749   {
12750     try {
12751       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12752     } catch (std::out_of_range& e) {
12753       {
12754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12755       };
12756     } catch (std::exception& e) {
12757       {
12758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12759       };
12760     } catch (Dali::DaliException e) {
12761       {
12762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12763       };
12764     } catch (...) {
12765       {
12766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12767       };
12768     }
12769   }
12770
12771 }
12772
12773
12774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12775   void * jresult ;
12776   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12777   Dali::Vector4 *result = 0 ;
12778
12779   arg1 = (Dali::Matrix *)jarg1;
12780   {
12781     try {
12782       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12783     } catch (std::out_of_range& e) {
12784       {
12785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12786       };
12787     } catch (std::exception& e) {
12788       {
12789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12790       };
12791     } catch (Dali::DaliException e) {
12792       {
12793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12794       };
12795     } catch (...) {
12796       {
12797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12798       };
12799     }
12800   }
12801
12802   jresult = (void *)result;
12803   return jresult;
12804 }
12805
12806
12807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12808   void * jresult ;
12809   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12810   Dali::Vector3 *result = 0 ;
12811
12812   arg1 = (Dali::Matrix *)jarg1;
12813   {
12814     try {
12815       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12816     } catch (std::out_of_range& e) {
12817       {
12818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12819       };
12820     } catch (std::exception& e) {
12821       {
12822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12823       };
12824     } catch (Dali::DaliException e) {
12825       {
12826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12827       };
12828     } catch (...) {
12829       {
12830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12831       };
12832     }
12833   }
12834
12835   jresult = (void *)result;
12836   return jresult;
12837 }
12838
12839
12840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12841   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12842   Dali::Vector4 *arg2 = 0 ;
12843
12844   arg1 = (Dali::Matrix *)jarg1;
12845   arg2 = (Dali::Vector4 *)jarg2;
12846   if (!arg2) {
12847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12848     return ;
12849   }
12850   {
12851     try {
12852       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12853     } catch (std::out_of_range& e) {
12854       {
12855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12856       };
12857     } catch (std::exception& e) {
12858       {
12859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12860       };
12861     } catch (Dali::DaliException e) {
12862       {
12863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12864       };
12865     } catch (...) {
12866       {
12867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12868       };
12869     }
12870   }
12871
12872 }
12873
12874
12875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12876   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12877   Dali::Vector3 *arg2 = 0 ;
12878
12879   arg1 = (Dali::Matrix *)jarg1;
12880   arg2 = (Dali::Vector3 *)jarg2;
12881   if (!arg2) {
12882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12883     return ;
12884   }
12885   {
12886     try {
12887       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12888     } catch (std::out_of_range& e) {
12889       {
12890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12891       };
12892     } catch (std::exception& e) {
12893       {
12894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12895       };
12896     } catch (Dali::DaliException e) {
12897       {
12898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12899       };
12900     } catch (...) {
12901       {
12902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12903       };
12904     }
12905   }
12906
12907 }
12908
12909
12910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12911   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12912
12913   arg1 = (Dali::Matrix *)jarg1;
12914   {
12915     try {
12916       (arg1)->OrthoNormalize();
12917     } catch (std::out_of_range& e) {
12918       {
12919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12920       };
12921     } catch (std::exception& e) {
12922       {
12923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12924       };
12925     } catch (Dali::DaliException e) {
12926       {
12927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12928       };
12929     } catch (...) {
12930       {
12931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12932       };
12933     }
12934   }
12935
12936 }
12937
12938
12939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12940   void * jresult ;
12941   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12942   float *result = 0 ;
12943
12944   arg1 = (Dali::Matrix *)jarg1;
12945   {
12946     try {
12947       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12948     } catch (std::out_of_range& e) {
12949       {
12950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12951       };
12952     } catch (std::exception& e) {
12953       {
12954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12955       };
12956     } catch (Dali::DaliException e) {
12957       {
12958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12959       };
12960     } catch (...) {
12961       {
12962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12963       };
12964     }
12965   }
12966
12967   jresult = (void *)result;
12968   return jresult;
12969 }
12970
12971
12972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12973   Dali::Matrix *arg1 = 0 ;
12974   Dali::Matrix *arg2 = 0 ;
12975   Dali::Matrix *arg3 = 0 ;
12976
12977   arg1 = (Dali::Matrix *)jarg1;
12978   if (!arg1) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12980     return ;
12981   }
12982   arg2 = (Dali::Matrix *)jarg2;
12983   if (!arg2) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   arg3 = (Dali::Matrix *)jarg3;
12988   if (!arg3) {
12989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12990     return ;
12991   }
12992   {
12993     try {
12994       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12995     } catch (std::out_of_range& e) {
12996       {
12997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12998       };
12999     } catch (std::exception& e) {
13000       {
13001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13002       };
13003     } catch (Dali::DaliException e) {
13004       {
13005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13006       };
13007     } catch (...) {
13008       {
13009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13010       };
13011     }
13012   }
13013
13014 }
13015
13016
13017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13018   Dali::Matrix *arg1 = 0 ;
13019   Dali::Matrix *arg2 = 0 ;
13020   Dali::Quaternion *arg3 = 0 ;
13021
13022   arg1 = (Dali::Matrix *)jarg1;
13023   if (!arg1) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13025     return ;
13026   }
13027   arg2 = (Dali::Matrix *)jarg2;
13028   if (!arg2) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13030     return ;
13031   }
13032   arg3 = (Dali::Quaternion *)jarg3;
13033   if (!arg3) {
13034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13035     return ;
13036   }
13037   {
13038     try {
13039       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13040     } catch (std::out_of_range& e) {
13041       {
13042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13043       };
13044     } catch (std::exception& e) {
13045       {
13046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13047       };
13048     } catch (Dali::DaliException e) {
13049       {
13050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13051       };
13052     } catch (...) {
13053       {
13054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13055       };
13056     }
13057   }
13058
13059 }
13060
13061
13062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13063   void * jresult ;
13064   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13065   Dali::Vector4 *arg2 = 0 ;
13066   Dali::Vector4 result;
13067
13068   arg1 = (Dali::Matrix *)jarg1;
13069   arg2 = (Dali::Vector4 *)jarg2;
13070   if (!arg2) {
13071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13072     return 0;
13073   }
13074   {
13075     try {
13076       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13077     } catch (std::out_of_range& e) {
13078       {
13079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13080       };
13081     } catch (std::exception& e) {
13082       {
13083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13084       };
13085     } catch (Dali::DaliException e) {
13086       {
13087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13088       };
13089     } catch (...) {
13090       {
13091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13092       };
13093     }
13094   }
13095
13096   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13097   return jresult;
13098 }
13099
13100
13101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13102   unsigned int jresult ;
13103   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13104   Dali::Matrix *arg2 = 0 ;
13105   bool result;
13106
13107   arg1 = (Dali::Matrix *)jarg1;
13108   arg2 = (Dali::Matrix *)jarg2;
13109   if (!arg2) {
13110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13111     return 0;
13112   }
13113   {
13114     try {
13115       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13116     } catch (std::out_of_range& e) {
13117       {
13118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13119       };
13120     } catch (std::exception& e) {
13121       {
13122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13123       };
13124     } catch (Dali::DaliException e) {
13125       {
13126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13127       };
13128     } catch (...) {
13129       {
13130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13131       };
13132     }
13133   }
13134
13135   jresult = result;
13136   return jresult;
13137 }
13138
13139
13140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13141   unsigned int jresult ;
13142   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13143   Dali::Matrix *arg2 = 0 ;
13144   bool result;
13145
13146   arg1 = (Dali::Matrix *)jarg1;
13147   arg2 = (Dali::Matrix *)jarg2;
13148   if (!arg2) {
13149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13150     return 0;
13151   }
13152   {
13153     try {
13154       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13155     } catch (std::out_of_range& e) {
13156       {
13157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13158       };
13159     } catch (std::exception& e) {
13160       {
13161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13162       };
13163     } catch (Dali::DaliException e) {
13164       {
13165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13166       };
13167     } catch (...) {
13168       {
13169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13170       };
13171     }
13172   }
13173
13174   jresult = result;
13175   return jresult;
13176 }
13177
13178
13179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13180   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13181   Dali::Vector3 *arg2 = 0 ;
13182   Dali::Quaternion *arg3 = 0 ;
13183   Dali::Vector3 *arg4 = 0 ;
13184
13185   arg1 = (Dali::Matrix *)jarg1;
13186   arg2 = (Dali::Vector3 *)jarg2;
13187   if (!arg2) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13189     return ;
13190   }
13191   arg3 = (Dali::Quaternion *)jarg3;
13192   if (!arg3) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13194     return ;
13195   }
13196   arg4 = (Dali::Vector3 *)jarg4;
13197   if (!arg4) {
13198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13199     return ;
13200   }
13201   {
13202     try {
13203       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13204     } catch (std::out_of_range& e) {
13205       {
13206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13207       };
13208     } catch (std::exception& e) {
13209       {
13210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13211       };
13212     } catch (Dali::DaliException e) {
13213       {
13214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13215       };
13216     } catch (...) {
13217       {
13218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13219       };
13220     }
13221   }
13222
13223 }
13224
13225
13226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13227   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13228   Dali::Vector3 *arg2 = 0 ;
13229   Dali::Quaternion *arg3 = 0 ;
13230   Dali::Vector3 *arg4 = 0 ;
13231
13232   arg1 = (Dali::Matrix *)jarg1;
13233   arg2 = (Dali::Vector3 *)jarg2;
13234   if (!arg2) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13236     return ;
13237   }
13238   arg3 = (Dali::Quaternion *)jarg3;
13239   if (!arg3) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13241     return ;
13242   }
13243   arg4 = (Dali::Vector3 *)jarg4;
13244   if (!arg4) {
13245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13246     return ;
13247   }
13248   {
13249     try {
13250       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13251     } catch (std::out_of_range& e) {
13252       {
13253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13254       };
13255     } catch (std::exception& e) {
13256       {
13257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13258       };
13259     } catch (Dali::DaliException e) {
13260       {
13261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13262       };
13263     } catch (...) {
13264       {
13265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13266       };
13267     }
13268   }
13269
13270 }
13271
13272
13273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13274   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13275   Dali::Vector3 *arg2 = 0 ;
13276   Dali::Vector3 *arg3 = 0 ;
13277   Dali::Vector3 *arg4 = 0 ;
13278   Dali::Vector3 *arg5 = 0 ;
13279
13280   arg1 = (Dali::Matrix *)jarg1;
13281   arg2 = (Dali::Vector3 *)jarg2;
13282   if (!arg2) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg3 = (Dali::Vector3 *)jarg3;
13287   if (!arg3) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg4 = (Dali::Vector3 *)jarg4;
13292   if (!arg4) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   arg5 = (Dali::Vector3 *)jarg5;
13297   if (!arg5) {
13298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13299     return ;
13300   }
13301   {
13302     try {
13303       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13304     } catch (std::out_of_range& e) {
13305       {
13306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13307       };
13308     } catch (std::exception& e) {
13309       {
13310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13311       };
13312     } catch (Dali::DaliException e) {
13313       {
13314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13315       };
13316     } catch (...) {
13317       {
13318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13319       };
13320     }
13321   }
13322
13323 }
13324
13325
13326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13327   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13328   Dali::Vector3 *arg2 = 0 ;
13329   Dali::Quaternion *arg3 = 0 ;
13330   Dali::Vector3 *arg4 = 0 ;
13331
13332   arg1 = (Dali::Matrix *)jarg1;
13333   arg2 = (Dali::Vector3 *)jarg2;
13334   if (!arg2) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13336     return ;
13337   }
13338   arg3 = (Dali::Quaternion *)jarg3;
13339   if (!arg3) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13341     return ;
13342   }
13343   arg4 = (Dali::Vector3 *)jarg4;
13344   if (!arg4) {
13345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13346     return ;
13347   }
13348   {
13349     try {
13350       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13351     } catch (std::out_of_range& e) {
13352       {
13353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13354       };
13355     } catch (std::exception& e) {
13356       {
13357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13358       };
13359     } catch (Dali::DaliException e) {
13360       {
13361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13362       };
13363     } catch (...) {
13364       {
13365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13366       };
13367     }
13368   }
13369
13370 }
13371
13372
13373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13374   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13375
13376   arg1 = (Dali::Matrix *)jarg1;
13377   {
13378     try {
13379       delete arg1;
13380     } catch (std::out_of_range& e) {
13381       {
13382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13383       };
13384     } catch (std::exception& e) {
13385       {
13386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13387       };
13388     } catch (Dali::DaliException e) {
13389       {
13390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13391       };
13392     } catch (...) {
13393       {
13394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13395       };
13396     }
13397   }
13398
13399 }
13400
13401
13402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13403   void * jresult ;
13404   Dali::Matrix3 *result = 0 ;
13405
13406   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13407   jresult = (void *)result;
13408   return jresult;
13409 }
13410
13411
13412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13413   void * jresult ;
13414   Dali::Matrix3 *result = 0 ;
13415
13416   {
13417     try {
13418       result = (Dali::Matrix3 *)new Dali::Matrix3();
13419     } catch (std::out_of_range& e) {
13420       {
13421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13422       };
13423     } catch (std::exception& e) {
13424       {
13425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13426       };
13427     } catch (Dali::DaliException e) {
13428       {
13429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13430       };
13431     } catch (...) {
13432       {
13433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13434       };
13435     }
13436   }
13437
13438   jresult = (void *)result;
13439   return jresult;
13440 }
13441
13442
13443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13444   void * jresult ;
13445   Dali::Matrix3 *arg1 = 0 ;
13446   Dali::Matrix3 *result = 0 ;
13447
13448   arg1 = (Dali::Matrix3 *)jarg1;
13449   if (!arg1) {
13450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13451     return 0;
13452   }
13453   {
13454     try {
13455       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13456     } catch (std::out_of_range& e) {
13457       {
13458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13459       };
13460     } catch (std::exception& e) {
13461       {
13462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13463       };
13464     } catch (Dali::DaliException e) {
13465       {
13466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13467       };
13468     } catch (...) {
13469       {
13470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13471       };
13472     }
13473   }
13474
13475   jresult = (void *)result;
13476   return jresult;
13477 }
13478
13479
13480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13481   void * jresult ;
13482   Dali::Matrix *arg1 = 0 ;
13483   Dali::Matrix3 *result = 0 ;
13484
13485   arg1 = (Dali::Matrix *)jarg1;
13486   if (!arg1) {
13487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13488     return 0;
13489   }
13490   {
13491     try {
13492       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13493     } catch (std::out_of_range& e) {
13494       {
13495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13496       };
13497     } catch (std::exception& e) {
13498       {
13499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13500       };
13501     } catch (Dali::DaliException e) {
13502       {
13503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13504       };
13505     } catch (...) {
13506       {
13507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13508       };
13509     }
13510   }
13511
13512   jresult = (void *)result;
13513   return jresult;
13514 }
13515
13516
13517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_3(float jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7, float jarg8, float jarg9) {
13518   void * jresult ;
13519   float arg1 ;
13520   float arg2 ;
13521   float arg3 ;
13522   float arg4 ;
13523   float arg5 ;
13524   float arg6 ;
13525   float arg7 ;
13526   float arg8 ;
13527   float arg9 ;
13528   Dali::Matrix3 *result = 0 ;
13529
13530   arg1 = (float)jarg1;
13531   arg2 = (float)jarg2;
13532   arg3 = (float)jarg3;
13533   arg4 = (float)jarg4;
13534   arg5 = (float)jarg5;
13535   arg6 = (float)jarg6;
13536   arg7 = (float)jarg7;
13537   arg8 = (float)jarg8;
13538   arg9 = (float)jarg9;
13539   {
13540     try {
13541       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13542     } catch (std::out_of_range& e) {
13543       {
13544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13545       };
13546     } catch (std::exception& e) {
13547       {
13548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13549       };
13550     } catch (Dali::DaliException e) {
13551       {
13552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13553       };
13554     } catch (...) {
13555       {
13556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13557       };
13558     }
13559   }
13560
13561   jresult = (void *)result;
13562   return jresult;
13563 }
13564
13565
13566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13567   void * jresult ;
13568   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13569   Dali::Matrix3 *arg2 = 0 ;
13570   Dali::Matrix3 *result = 0 ;
13571
13572   arg1 = (Dali::Matrix3 *)jarg1;
13573   arg2 = (Dali::Matrix3 *)jarg2;
13574   if (!arg2) {
13575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13576     return 0;
13577   }
13578   {
13579     try {
13580       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13581     } catch (std::out_of_range& e) {
13582       {
13583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13584       };
13585     } catch (std::exception& e) {
13586       {
13587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13588       };
13589     } catch (Dali::DaliException e) {
13590       {
13591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13592       };
13593     } catch (...) {
13594       {
13595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13596       };
13597     }
13598   }
13599
13600   jresult = (void *)result;
13601   return jresult;
13602 }
13603
13604
13605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13606   void * jresult ;
13607   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13608   Dali::Matrix *arg2 = 0 ;
13609   Dali::Matrix3 *result = 0 ;
13610
13611   arg1 = (Dali::Matrix3 *)jarg1;
13612   arg2 = (Dali::Matrix *)jarg2;
13613   if (!arg2) {
13614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13615     return 0;
13616   }
13617   {
13618     try {
13619       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13620     } catch (std::out_of_range& e) {
13621       {
13622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13623       };
13624     } catch (std::exception& e) {
13625       {
13626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13627       };
13628     } catch (Dali::DaliException e) {
13629       {
13630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13631       };
13632     } catch (...) {
13633       {
13634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13635       };
13636     }
13637   }
13638
13639   jresult = (void *)result;
13640   return jresult;
13641 }
13642
13643
13644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13645   unsigned int jresult ;
13646   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13647   Dali::Matrix3 *arg2 = 0 ;
13648   bool result;
13649
13650   arg1 = (Dali::Matrix3 *)jarg1;
13651   arg2 = (Dali::Matrix3 *)jarg2;
13652   if (!arg2) {
13653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13654     return 0;
13655   }
13656   {
13657     try {
13658       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13659     } catch (std::out_of_range& e) {
13660       {
13661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13662       };
13663     } catch (std::exception& e) {
13664       {
13665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13666       };
13667     } catch (Dali::DaliException e) {
13668       {
13669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13670       };
13671     } catch (...) {
13672       {
13673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13674       };
13675     }
13676   }
13677
13678   jresult = result;
13679   return jresult;
13680 }
13681
13682
13683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13684   unsigned int jresult ;
13685   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13686   Dali::Matrix3 *arg2 = 0 ;
13687   bool result;
13688
13689   arg1 = (Dali::Matrix3 *)jarg1;
13690   arg2 = (Dali::Matrix3 *)jarg2;
13691   if (!arg2) {
13692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13693     return 0;
13694   }
13695   {
13696     try {
13697       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13698     } catch (std::out_of_range& e) {
13699       {
13700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13701       };
13702     } catch (std::exception& e) {
13703       {
13704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13705       };
13706     } catch (Dali::DaliException e) {
13707       {
13708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13709       };
13710     } catch (...) {
13711       {
13712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13713       };
13714     }
13715   }
13716
13717   jresult = result;
13718   return jresult;
13719 }
13720
13721
13722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13723   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13724
13725   arg1 = (Dali::Matrix3 *)jarg1;
13726   {
13727     try {
13728       delete arg1;
13729     } catch (std::out_of_range& e) {
13730       {
13731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13732       };
13733     } catch (std::exception& e) {
13734       {
13735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13736       };
13737     } catch (Dali::DaliException e) {
13738       {
13739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13740       };
13741     } catch (...) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13744       };
13745     }
13746   }
13747
13748 }
13749
13750
13751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13752   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13753
13754   arg1 = (Dali::Matrix3 *)jarg1;
13755   {
13756     try {
13757       (arg1)->SetIdentity();
13758     } catch (std::out_of_range& e) {
13759       {
13760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13761       };
13762     } catch (std::exception& e) {
13763       {
13764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13765       };
13766     } catch (Dali::DaliException e) {
13767       {
13768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13769       };
13770     } catch (...) {
13771       {
13772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13773       };
13774     }
13775   }
13776
13777 }
13778
13779
13780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13781   void * jresult ;
13782   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13783   float *result = 0 ;
13784
13785   arg1 = (Dali::Matrix3 *)jarg1;
13786   {
13787     try {
13788       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13789     } catch (std::out_of_range& e) {
13790       {
13791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13792       };
13793     } catch (std::exception& e) {
13794       {
13795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13796       };
13797     } catch (Dali::DaliException e) {
13798       {
13799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13800       };
13801     } catch (...) {
13802       {
13803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13804       };
13805     }
13806   }
13807
13808   jresult = (void *)result;
13809   return jresult;
13810 }
13811
13812
13813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13814   unsigned int jresult ;
13815   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13816   bool result;
13817
13818   arg1 = (Dali::Matrix3 *)jarg1;
13819   {
13820     try {
13821       result = (bool)(arg1)->Invert();
13822     } catch (std::out_of_range& e) {
13823       {
13824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (std::exception& e) {
13827       {
13828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13829       };
13830     } catch (Dali::DaliException e) {
13831       {
13832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13833       };
13834     } catch (...) {
13835       {
13836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13837       };
13838     }
13839   }
13840
13841   jresult = result;
13842   return jresult;
13843 }
13844
13845
13846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13847   unsigned int jresult ;
13848   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13849   bool result;
13850
13851   arg1 = (Dali::Matrix3 *)jarg1;
13852   {
13853     try {
13854       result = (bool)(arg1)->Transpose();
13855     } catch (std::out_of_range& e) {
13856       {
13857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13858       };
13859     } catch (std::exception& e) {
13860       {
13861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13862       };
13863     } catch (Dali::DaliException e) {
13864       {
13865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13866       };
13867     } catch (...) {
13868       {
13869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13870       };
13871     }
13872   }
13873
13874   jresult = result;
13875   return jresult;
13876 }
13877
13878
13879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13880   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13881   float arg2 ;
13882
13883   arg1 = (Dali::Matrix3 *)jarg1;
13884   arg2 = (float)jarg2;
13885   {
13886     try {
13887       (arg1)->Scale(arg2);
13888     } catch (std::out_of_range& e) {
13889       {
13890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13891       };
13892     } catch (std::exception& e) {
13893       {
13894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13895       };
13896     } catch (Dali::DaliException e) {
13897       {
13898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13899       };
13900     } catch (...) {
13901       {
13902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13903       };
13904     }
13905   }
13906
13907 }
13908
13909
13910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13911   float jresult ;
13912   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13913   float result;
13914
13915   arg1 = (Dali::Matrix3 *)jarg1;
13916   {
13917     try {
13918       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13919     } catch (std::out_of_range& e) {
13920       {
13921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13922       };
13923     } catch (std::exception& e) {
13924       {
13925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13926       };
13927     } catch (Dali::DaliException e) {
13928       {
13929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13930       };
13931     } catch (...) {
13932       {
13933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13934       };
13935     }
13936   }
13937
13938   jresult = result;
13939   return jresult;
13940 }
13941
13942
13943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13944   unsigned int jresult ;
13945   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13946   bool result;
13947
13948   arg1 = (Dali::Matrix3 *)jarg1;
13949   {
13950     try {
13951       result = (bool)(arg1)->ScaledInverseTranspose();
13952     } catch (std::out_of_range& e) {
13953       {
13954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13955       };
13956     } catch (std::exception& e) {
13957       {
13958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13959       };
13960     } catch (Dali::DaliException e) {
13961       {
13962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13963       };
13964     } catch (...) {
13965       {
13966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13967       };
13968     }
13969   }
13970
13971   jresult = result;
13972   return jresult;
13973 }
13974
13975
13976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13977   Dali::Matrix3 *arg1 = 0 ;
13978   Dali::Matrix3 *arg2 = 0 ;
13979   Dali::Matrix3 *arg3 = 0 ;
13980
13981   arg1 = (Dali::Matrix3 *)jarg1;
13982   if (!arg1) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13984     return ;
13985   }
13986   arg2 = (Dali::Matrix3 *)jarg2;
13987   if (!arg2) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   arg3 = (Dali::Matrix3 *)jarg3;
13992   if (!arg3) {
13993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13994     return ;
13995   }
13996   {
13997     try {
13998       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13999     } catch (std::out_of_range& e) {
14000       {
14001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14002       };
14003     } catch (std::exception& e) {
14004       {
14005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14006       };
14007     } catch (Dali::DaliException e) {
14008       {
14009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14010       };
14011     } catch (...) {
14012       {
14013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14014       };
14015     }
14016   }
14017
14018 }
14019
14020
14021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14022   float jresult ;
14023   float arg1 ;
14024   float arg2 ;
14025   float result;
14026
14027   arg1 = (float)jarg1;
14028   arg2 = (float)jarg2;
14029   {
14030     try {
14031       result = (float)Dali::Random::Range(arg1,arg2);
14032     } catch (std::out_of_range& e) {
14033       {
14034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14035       };
14036     } catch (std::exception& e) {
14037       {
14038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14039       };
14040     } catch (Dali::DaliException e) {
14041       {
14042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14043       };
14044     } catch (...) {
14045       {
14046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14047       };
14048     }
14049   }
14050
14051   jresult = result;
14052   return jresult;
14053 }
14054
14055
14056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14057   void * jresult ;
14058   Dali::Vector4 result;
14059
14060   {
14061     try {
14062       result = Dali::Random::Axis();
14063     } catch (std::out_of_range& e) {
14064       {
14065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14066       };
14067     } catch (std::exception& e) {
14068       {
14069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14070       };
14071     } catch (Dali::DaliException e) {
14072       {
14073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14074       };
14075     } catch (...) {
14076       {
14077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14078       };
14079     }
14080   }
14081
14082   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14083   return jresult;
14084 }
14085
14086
14087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14088   void * jresult ;
14089   Dali::AngleAxis *result = 0 ;
14090
14091   {
14092     try {
14093       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14094     } catch (std::out_of_range& e) {
14095       {
14096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14097       };
14098     } catch (std::exception& e) {
14099       {
14100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14101       };
14102     } catch (Dali::DaliException e) {
14103       {
14104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14105       };
14106     } catch (...) {
14107       {
14108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14109       };
14110     }
14111   }
14112
14113   jresult = (void *)result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14119   void * jresult ;
14120   Dali::Radian arg1 ;
14121   Dali::Vector3 *arg2 = 0 ;
14122   Dali::Radian *argp1 ;
14123   Dali::AngleAxis *result = 0 ;
14124
14125   argp1 = (Dali::Radian *)jarg1;
14126   if (!argp1) {
14127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14128     return 0;
14129   }
14130   arg1 = *argp1;
14131   arg2 = (Dali::Vector3 *)jarg2;
14132   if (!arg2) {
14133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14134     return 0;
14135   }
14136   {
14137     try {
14138       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14139     } catch (std::out_of_range& e) {
14140       {
14141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14142       };
14143     } catch (std::exception& e) {
14144       {
14145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14146       };
14147     } catch (Dali::DaliException e) {
14148       {
14149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14150       };
14151     } catch (...) {
14152       {
14153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14154       };
14155     }
14156   }
14157
14158   jresult = (void *)result;
14159   return jresult;
14160 }
14161
14162
14163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14164   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14165   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14166
14167   arg1 = (Dali::AngleAxis *)jarg1;
14168   arg2 = (Dali::Radian *)jarg2;
14169   if (arg1) (arg1)->angle = *arg2;
14170 }
14171
14172
14173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14174   void * jresult ;
14175   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14176   Dali::Radian *result = 0 ;
14177
14178   arg1 = (Dali::AngleAxis *)jarg1;
14179   result = (Dali::Radian *)& ((arg1)->angle);
14180   jresult = (void *)result;
14181   return jresult;
14182 }
14183
14184
14185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14186   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14187   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   arg2 = (Dali::Vector3 *)jarg2;
14191   if (arg1) (arg1)->axis = *arg2;
14192 }
14193
14194
14195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14196   void * jresult ;
14197   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14198   Dali::Vector3 *result = 0 ;
14199
14200   arg1 = (Dali::AngleAxis *)jarg1;
14201   result = (Dali::Vector3 *)& ((arg1)->axis);
14202   jresult = (void *)result;
14203   return jresult;
14204 }
14205
14206
14207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14208   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14209
14210   arg1 = (Dali::AngleAxis *)jarg1;
14211   {
14212     try {
14213       delete arg1;
14214     } catch (std::out_of_range& e) {
14215       {
14216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14217       };
14218     } catch (std::exception& e) {
14219       {
14220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14221       };
14222     } catch (Dali::DaliException e) {
14223       {
14224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14225       };
14226     } catch (...) {
14227       {
14228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14229       };
14230     }
14231   }
14232
14233 }
14234
14235
14236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14237   unsigned int jresult ;
14238   Dali::AngleAxis *arg1 = 0 ;
14239   Dali::AngleAxis *arg2 = 0 ;
14240   bool result;
14241
14242   arg1 = (Dali::AngleAxis *)jarg1;
14243   if (!arg1) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   arg2 = (Dali::AngleAxis *)jarg2;
14248   if (!arg2) {
14249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14250     return 0;
14251   }
14252   {
14253     try {
14254       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14255     } catch (std::out_of_range& e) {
14256       {
14257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14258       };
14259     } catch (std::exception& e) {
14260       {
14261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14262       };
14263     } catch (Dali::DaliException e) {
14264       {
14265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14266       };
14267     } catch (...) {
14268       {
14269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14270       };
14271     }
14272   }
14273
14274   jresult = result;
14275   return jresult;
14276 }
14277
14278
14279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14280   unsigned int jresult ;
14281   unsigned int arg1 ;
14282   unsigned int result;
14283
14284   arg1 = (unsigned int)jarg1;
14285   {
14286     try {
14287       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14288     } catch (std::out_of_range& e) {
14289       {
14290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14291       };
14292     } catch (std::exception& e) {
14293       {
14294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14295       };
14296     } catch (Dali::DaliException e) {
14297       {
14298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14299       };
14300     } catch (...) {
14301       {
14302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14303       };
14304     }
14305   }
14306
14307   jresult = result;
14308   return jresult;
14309 }
14310
14311
14312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14313   unsigned int jresult ;
14314   unsigned int arg1 ;
14315   bool result;
14316
14317   arg1 = (unsigned int)jarg1;
14318   {
14319     try {
14320       result = (bool)Dali::IsPowerOfTwo(arg1);
14321     } catch (std::out_of_range& e) {
14322       {
14323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14324       };
14325     } catch (std::exception& e) {
14326       {
14327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14328       };
14329     } catch (Dali::DaliException e) {
14330       {
14331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14332       };
14333     } catch (...) {
14334       {
14335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14336       };
14337     }
14338   }
14339
14340   jresult = result;
14341   return jresult;
14342 }
14343
14344
14345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14346   float jresult ;
14347   float arg1 ;
14348   float arg2 ;
14349   float result;
14350
14351   arg1 = (float)jarg1;
14352   arg2 = (float)jarg2;
14353   {
14354     try {
14355       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14356     } catch (std::out_of_range& e) {
14357       {
14358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14359       };
14360     } catch (std::exception& e) {
14361       {
14362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14363       };
14364     } catch (Dali::DaliException e) {
14365       {
14366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14367       };
14368     } catch (...) {
14369       {
14370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14371       };
14372     }
14373   }
14374
14375   jresult = result;
14376   return jresult;
14377 }
14378
14379
14380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14381   unsigned int jresult ;
14382   float arg1 ;
14383   bool result;
14384
14385   arg1 = (float)jarg1;
14386   {
14387     try {
14388       result = (bool)Dali::EqualsZero(arg1);
14389     } catch (std::out_of_range& e) {
14390       {
14391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (std::exception& e) {
14394       {
14395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14396       };
14397     } catch (Dali::DaliException e) {
14398       {
14399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14400       };
14401     } catch (...) {
14402       {
14403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14404       };
14405     }
14406   }
14407
14408   jresult = result;
14409   return jresult;
14410 }
14411
14412
14413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14414   unsigned int jresult ;
14415   float arg1 ;
14416   float arg2 ;
14417   bool result;
14418
14419   arg1 = (float)jarg1;
14420   arg2 = (float)jarg2;
14421   {
14422     try {
14423       result = (bool)Dali::Equals(arg1,arg2);
14424     } catch (std::out_of_range& e) {
14425       {
14426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14427       };
14428     } catch (std::exception& e) {
14429       {
14430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14431       };
14432     } catch (Dali::DaliException e) {
14433       {
14434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14435       };
14436     } catch (...) {
14437       {
14438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14439       };
14440     }
14441   }
14442
14443   jresult = result;
14444   return jresult;
14445 }
14446
14447
14448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14449   unsigned int jresult ;
14450   float arg1 ;
14451   float arg2 ;
14452   float arg3 ;
14453   bool result;
14454
14455   arg1 = (float)jarg1;
14456   arg2 = (float)jarg2;
14457   arg3 = (float)jarg3;
14458   {
14459     try {
14460       result = (bool)Dali::Equals(arg1,arg2,arg3);
14461     } catch (std::out_of_range& e) {
14462       {
14463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14464       };
14465     } catch (std::exception& e) {
14466       {
14467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14468       };
14469     } catch (Dali::DaliException e) {
14470       {
14471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14472       };
14473     } catch (...) {
14474       {
14475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14476       };
14477     }
14478   }
14479
14480   jresult = result;
14481   return jresult;
14482 }
14483
14484
14485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14486   float jresult ;
14487   float arg1 ;
14488   int arg2 ;
14489   float result;
14490
14491   arg1 = (float)jarg1;
14492   arg2 = (int)jarg2;
14493   {
14494     try {
14495       result = (float)Dali::Round(arg1,arg2);
14496     } catch (std::out_of_range& e) {
14497       {
14498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14499       };
14500     } catch (std::exception& e) {
14501       {
14502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14503       };
14504     } catch (Dali::DaliException e) {
14505       {
14506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14507       };
14508     } catch (...) {
14509       {
14510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14511       };
14512     }
14513   }
14514
14515   jresult = result;
14516   return jresult;
14517 }
14518
14519
14520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14521   float jresult ;
14522   float arg1 ;
14523   float arg2 ;
14524   float arg3 ;
14525   float result;
14526
14527   arg1 = (float)jarg1;
14528   arg2 = (float)jarg2;
14529   arg3 = (float)jarg3;
14530   {
14531     try {
14532       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14533     } catch (std::out_of_range& e) {
14534       {
14535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14536       };
14537     } catch (std::exception& e) {
14538       {
14539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14540       };
14541     } catch (Dali::DaliException e) {
14542       {
14543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14544       };
14545     } catch (...) {
14546       {
14547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14548       };
14549     }
14550   }
14551
14552   jresult = result;
14553   return jresult;
14554 }
14555
14556
14557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14558   float jresult ;
14559   float arg1 ;
14560   float arg2 ;
14561   float arg3 ;
14562   float arg4 ;
14563   float result;
14564
14565   arg1 = (float)jarg1;
14566   arg2 = (float)jarg2;
14567   arg3 = (float)jarg3;
14568   arg4 = (float)jarg4;
14569   {
14570     try {
14571       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14572     } catch (std::out_of_range& e) {
14573       {
14574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (std::exception& e) {
14577       {
14578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14579       };
14580     } catch (Dali::DaliException e) {
14581       {
14582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14583       };
14584     } catch (...) {
14585       {
14586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14587       };
14588     }
14589   }
14590
14591   jresult = result;
14592   return jresult;
14593 }
14594
14595
14596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14597   int jresult ;
14598   int result;
14599
14600   result = (int)(int)Dali::Property::INVALID_INDEX;
14601   jresult = result;
14602   return jresult;
14603 }
14604
14605
14606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14607   int jresult ;
14608   int result;
14609
14610   result = (int)(int)Dali::Property::INVALID_KEY;
14611   jresult = result;
14612   return jresult;
14613 }
14614
14615
14616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14617   int jresult ;
14618   int result;
14619
14620   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14621   jresult = result;
14622   return jresult;
14623 }
14624
14625
14626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14627   void * jresult ;
14628   Dali::Handle *arg1 = 0 ;
14629   Dali::Property::Index arg2 ;
14630   Dali::Property *result = 0 ;
14631
14632   arg1 = (Dali::Handle *)jarg1;
14633   if (!arg1) {
14634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14635     return 0;
14636   }
14637   arg2 = (Dali::Property::Index)jarg2;
14638   {
14639     try {
14640       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14641     } catch (std::out_of_range& e) {
14642       {
14643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14644       };
14645     } catch (std::exception& e) {
14646       {
14647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14648       };
14649     } catch (Dali::DaliException e) {
14650       {
14651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14652       };
14653     } catch (...) {
14654       {
14655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14656       };
14657     }
14658   }
14659
14660   jresult = (void *)result;
14661   return jresult;
14662 }
14663
14664
14665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14666   void * jresult ;
14667   Dali::Handle *arg1 = 0 ;
14668   Dali::Property::Index arg2 ;
14669   int arg3 ;
14670   Dali::Property *result = 0 ;
14671
14672   arg1 = (Dali::Handle *)jarg1;
14673   if (!arg1) {
14674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14675     return 0;
14676   }
14677   arg2 = (Dali::Property::Index)jarg2;
14678   arg3 = (int)jarg3;
14679   {
14680     try {
14681       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14682     } catch (std::out_of_range& e) {
14683       {
14684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14685       };
14686     } catch (std::exception& e) {
14687       {
14688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14689       };
14690     } catch (Dali::DaliException e) {
14691       {
14692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14693       };
14694     } catch (...) {
14695       {
14696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14697       };
14698     }
14699   }
14700
14701   jresult = (void *)result;
14702   return jresult;
14703 }
14704
14705
14706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14707   void * jresult ;
14708   Dali::Handle *arg1 = 0 ;
14709   std::string *arg2 = 0 ;
14710   Dali::Property *result = 0 ;
14711
14712   arg1 = (Dali::Handle *)jarg1;
14713   if (!arg1) {
14714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14715     return 0;
14716   }
14717   if (!jarg2) {
14718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14719     return 0;
14720   }
14721   std::string arg2_str(jarg2);
14722   arg2 = &arg2_str;
14723   {
14724     try {
14725       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14726     } catch (std::out_of_range& e) {
14727       {
14728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14729       };
14730     } catch (std::exception& e) {
14731       {
14732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14733       };
14734     } catch (Dali::DaliException e) {
14735       {
14736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14737       };
14738     } catch (...) {
14739       {
14740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14741       };
14742     }
14743   }
14744
14745   jresult = (void *)result;
14746
14747   //argout typemap for const std::string&
14748
14749   return jresult;
14750 }
14751
14752
14753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14754   void * jresult ;
14755   Dali::Handle *arg1 = 0 ;
14756   std::string *arg2 = 0 ;
14757   int arg3 ;
14758   Dali::Property *result = 0 ;
14759
14760   arg1 = (Dali::Handle *)jarg1;
14761   if (!arg1) {
14762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14763     return 0;
14764   }
14765   if (!jarg2) {
14766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14767     return 0;
14768   }
14769   std::string arg2_str(jarg2);
14770   arg2 = &arg2_str;
14771   arg3 = (int)jarg3;
14772   {
14773     try {
14774       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14775     } catch (std::out_of_range& e) {
14776       {
14777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14778       };
14779     } catch (std::exception& e) {
14780       {
14781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14782       };
14783     } catch (Dali::DaliException e) {
14784       {
14785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14786       };
14787     } catch (...) {
14788       {
14789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14790       };
14791     }
14792   }
14793
14794   jresult = (void *)result;
14795
14796   //argout typemap for const std::string&
14797
14798   return jresult;
14799 }
14800
14801
14802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14803   Dali::Property *arg1 = (Dali::Property *) 0 ;
14804
14805   arg1 = (Dali::Property *)jarg1;
14806   {
14807     try {
14808       delete arg1;
14809     } catch (std::out_of_range& e) {
14810       {
14811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14812       };
14813     } catch (std::exception& e) {
14814       {
14815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14816       };
14817     } catch (Dali::DaliException e) {
14818       {
14819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14820       };
14821     } catch (...) {
14822       {
14823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14824       };
14825     }
14826   }
14827
14828 }
14829
14830
14831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14832   Dali::Property *arg1 = (Dali::Property *) 0 ;
14833   Dali::Handle *arg2 = 0 ;
14834
14835   arg1 = (Dali::Property *)jarg1;
14836   arg2 = (Dali::Handle *)jarg2;
14837   if (!arg2) {
14838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14839     return ;
14840   }
14841   if (arg1) (arg1)->object = *arg2;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14846   void * jresult ;
14847   Dali::Property *arg1 = (Dali::Property *) 0 ;
14848   Dali::Handle *result = 0 ;
14849
14850   arg1 = (Dali::Property *)jarg1;
14851   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14852   jresult = (void *)result;
14853   return jresult;
14854 }
14855
14856
14857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14858   Dali::Property *arg1 = (Dali::Property *) 0 ;
14859   Dali::Property::Index arg2 ;
14860
14861   arg1 = (Dali::Property *)jarg1;
14862   arg2 = (Dali::Property::Index)jarg2;
14863   if (arg1) (arg1)->propertyIndex = arg2;
14864 }
14865
14866
14867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14868   int jresult ;
14869   Dali::Property *arg1 = (Dali::Property *) 0 ;
14870   Dali::Property::Index result;
14871
14872   arg1 = (Dali::Property *)jarg1;
14873   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14874   jresult = result;
14875   return jresult;
14876 }
14877
14878
14879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14880   Dali::Property *arg1 = (Dali::Property *) 0 ;
14881   int arg2 ;
14882
14883   arg1 = (Dali::Property *)jarg1;
14884   arg2 = (int)jarg2;
14885   if (arg1) (arg1)->componentIndex = arg2;
14886 }
14887
14888
14889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14890   int jresult ;
14891   Dali::Property *arg1 = (Dali::Property *) 0 ;
14892   int result;
14893
14894   arg1 = (Dali::Property *)jarg1;
14895   result = (int) ((arg1)->componentIndex);
14896   jresult = result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14902   void * jresult ;
14903   Dali::Property::Array *result = 0 ;
14904
14905   {
14906     try {
14907       result = (Dali::Property::Array *)new Dali::Property::Array();
14908     } catch (std::out_of_range& e) {
14909       {
14910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14911       };
14912     } catch (std::exception& e) {
14913       {
14914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14915       };
14916     } catch (Dali::DaliException e) {
14917       {
14918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14919       };
14920     } catch (...) {
14921       {
14922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14923       };
14924     }
14925   }
14926
14927   jresult = (void *)result;
14928   return jresult;
14929 }
14930
14931
14932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14933   void * jresult ;
14934   Dali::Property::Array *arg1 = 0 ;
14935   Dali::Property::Array *result = 0 ;
14936
14937   arg1 = (Dali::Property::Array *)jarg1;
14938   if (!arg1) {
14939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14940     return 0;
14941   }
14942   {
14943     try {
14944       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14945     } catch (std::out_of_range& e) {
14946       {
14947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14948       };
14949     } catch (std::exception& e) {
14950       {
14951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14952       };
14953     } catch (Dali::DaliException e) {
14954       {
14955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14956       };
14957     } catch (...) {
14958       {
14959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14960       };
14961     }
14962   }
14963
14964   jresult = (void *)result;
14965   return jresult;
14966 }
14967
14968
14969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14970   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14971
14972   arg1 = (Dali::Property::Array *)jarg1;
14973   {
14974     try {
14975       delete arg1;
14976     } catch (std::out_of_range& e) {
14977       {
14978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14979       };
14980     } catch (std::exception& e) {
14981       {
14982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14983       };
14984     } catch (Dali::DaliException e) {
14985       {
14986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14987       };
14988     } catch (...) {
14989       {
14990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14991       };
14992     }
14993   }
14994
14995 }
14996
14997
14998 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14999   unsigned long jresult ;
15000   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15001   Dali::Property::Array::SizeType result;
15002
15003   arg1 = (Dali::Property::Array *)jarg1;
15004   {
15005     try {
15006       result = ((Dali::Property::Array const *)arg1)->Size();
15007     } catch (std::out_of_range& e) {
15008       {
15009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15010       };
15011     } catch (std::exception& e) {
15012       {
15013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15014       };
15015     } catch (Dali::DaliException e) {
15016       {
15017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15018       };
15019     } catch (...) {
15020       {
15021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15022       };
15023     }
15024   }
15025
15026   jresult = (unsigned long)result;
15027   return jresult;
15028 }
15029
15030
15031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15032   unsigned long jresult ;
15033   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15034   Dali::Property::Array::SizeType result;
15035
15036   arg1 = (Dali::Property::Array *)jarg1;
15037   {
15038     try {
15039       result = ((Dali::Property::Array const *)arg1)->Count();
15040     } catch (std::out_of_range& e) {
15041       {
15042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15043       };
15044     } catch (std::exception& e) {
15045       {
15046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15047       };
15048     } catch (Dali::DaliException e) {
15049       {
15050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15051       };
15052     } catch (...) {
15053       {
15054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15055       };
15056     }
15057   }
15058
15059   jresult = (unsigned long)result;
15060   return jresult;
15061 }
15062
15063
15064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15065   unsigned int jresult ;
15066   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15067   bool result;
15068
15069   arg1 = (Dali::Property::Array *)jarg1;
15070   {
15071     try {
15072       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15073     } catch (std::out_of_range& e) {
15074       {
15075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15076       };
15077     } catch (std::exception& e) {
15078       {
15079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15080       };
15081     } catch (Dali::DaliException e) {
15082       {
15083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15084       };
15085     } catch (...) {
15086       {
15087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15088       };
15089     }
15090   }
15091
15092   jresult = result;
15093   return jresult;
15094 }
15095
15096
15097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15098   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15099
15100   arg1 = (Dali::Property::Array *)jarg1;
15101   {
15102     try {
15103       (arg1)->Clear();
15104     } catch (std::out_of_range& e) {
15105       {
15106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15107       };
15108     } catch (std::exception& e) {
15109       {
15110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15111       };
15112     } catch (Dali::DaliException e) {
15113       {
15114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15115       };
15116     } catch (...) {
15117       {
15118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15119       };
15120     }
15121   }
15122
15123 }
15124
15125
15126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15127   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15128   Dali::Property::Array::SizeType arg2 ;
15129
15130   arg1 = (Dali::Property::Array *)jarg1;
15131   arg2 = (Dali::Property::Array::SizeType)jarg2;
15132   {
15133     try {
15134       (arg1)->Reserve(arg2);
15135     } catch (std::out_of_range& e) {
15136       {
15137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15138       };
15139     } catch (std::exception& e) {
15140       {
15141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15142       };
15143     } catch (Dali::DaliException e) {
15144       {
15145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15146       };
15147     } catch (...) {
15148       {
15149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15150       };
15151     }
15152   }
15153
15154 }
15155
15156
15157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15158   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15159   Dali::Property::Array::SizeType arg2 ;
15160
15161   arg1 = (Dali::Property::Array *)jarg1;
15162   arg2 = (Dali::Property::Array::SizeType)jarg2;
15163   {
15164     try {
15165       (arg1)->Resize(arg2);
15166     } catch (std::out_of_range& e) {
15167       {
15168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15169       };
15170     } catch (std::exception& e) {
15171       {
15172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15173       };
15174     } catch (Dali::DaliException e) {
15175       {
15176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15177       };
15178     } catch (...) {
15179       {
15180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15181       };
15182     }
15183   }
15184
15185 }
15186
15187
15188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15189   unsigned long jresult ;
15190   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15191   Dali::Property::Array::SizeType result;
15192
15193   arg1 = (Dali::Property::Array *)jarg1;
15194   {
15195     try {
15196       result = (arg1)->Capacity();
15197     } catch (std::out_of_range& e) {
15198       {
15199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15200       };
15201     } catch (std::exception& e) {
15202       {
15203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15204       };
15205     } catch (Dali::DaliException e) {
15206       {
15207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15208       };
15209     } catch (...) {
15210       {
15211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15212       };
15213     }
15214   }
15215
15216   jresult = (unsigned long)result;
15217   return jresult;
15218 }
15219
15220
15221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15222   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15223   Dali::Property::Value *arg2 = 0 ;
15224
15225   arg1 = (Dali::Property::Array *)jarg1;
15226   arg2 = (Dali::Property::Value *)jarg2;
15227   if (!arg2) {
15228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15229     return ;
15230   }
15231   {
15232     try {
15233       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15234     } catch (std::out_of_range& e) {
15235       {
15236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15237       };
15238     } catch (std::exception& e) {
15239       {
15240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15241       };
15242     } catch (Dali::DaliException e) {
15243       {
15244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15245       };
15246     } catch (...) {
15247       {
15248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15249       };
15250     }
15251   }
15252
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15257   void * jresult ;
15258   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15259   Dali::Property::Value *arg2 = 0 ;
15260   Dali::Property::Array *result = 0 ;
15261
15262   arg1 = (Dali::Property::Array *)jarg1;
15263   arg2 = (Dali::Property::Value *)jarg2;
15264   if (!arg2) {
15265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15266     return 0;
15267   }
15268   {
15269     try {
15270       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15271     } catch (std::out_of_range& e) {
15272       {
15273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15274       };
15275     } catch (std::exception& e) {
15276       {
15277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15278       };
15279     } catch (Dali::DaliException e) {
15280       {
15281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15282       };
15283     } catch (...) {
15284       {
15285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15286       };
15287     }
15288   }
15289
15290   jresult = (void *)result;
15291   return jresult;
15292 }
15293
15294
15295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15296   void * jresult ;
15297   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15298   Dali::Property::Array::SizeType arg2 ;
15299   Dali::Property::Value *result = 0 ;
15300
15301   arg1 = (Dali::Property::Array *)jarg1;
15302   arg2 = (Dali::Property::Array::SizeType)jarg2;
15303   {
15304     try {
15305       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15306     } catch (std::out_of_range& e) {
15307       {
15308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (std::exception& e) {
15311       {
15312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15313       };
15314     } catch (Dali::DaliException e) {
15315       {
15316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15317       };
15318     } catch (...) {
15319       {
15320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15321       };
15322     }
15323   }
15324
15325   jresult = (void *)result;
15326   return jresult;
15327 }
15328
15329
15330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15331   void * jresult ;
15332   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15333   Dali::Property::Array::SizeType arg2 ;
15334   Dali::Property::Value *result = 0 ;
15335
15336   arg1 = (Dali::Property::Array *)jarg1;
15337   arg2 = (Dali::Property::Array::SizeType)jarg2;
15338   {
15339     try {
15340       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15341     } catch (std::out_of_range& e) {
15342       {
15343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15344       };
15345     } catch (std::exception& e) {
15346       {
15347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15348       };
15349     } catch (Dali::DaliException e) {
15350       {
15351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15352       };
15353     } catch (...) {
15354       {
15355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15356       };
15357     }
15358   }
15359
15360   jresult = (void *)result;
15361   return jresult;
15362 }
15363
15364
15365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15366   void * jresult ;
15367   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15368   Dali::Property::Array *arg2 = 0 ;
15369   Dali::Property::Array *result = 0 ;
15370
15371   arg1 = (Dali::Property::Array *)jarg1;
15372   arg2 = (Dali::Property::Array *)jarg2;
15373   if (!arg2) {
15374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15375     return 0;
15376   }
15377   {
15378     try {
15379       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15380     } catch (std::out_of_range& e) {
15381       {
15382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15383       };
15384     } catch (std::exception& e) {
15385       {
15386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15387       };
15388     } catch (Dali::DaliException e) {
15389       {
15390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15391       };
15392     } catch (...) {
15393       {
15394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15395       };
15396     }
15397   }
15398
15399   jresult = (void *)result;
15400   return jresult;
15401 }
15402
15403
15404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15405   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15406   enum Dali::Property::Key::Type arg2 ;
15407
15408   arg1 = (Dali::Property::Key *)jarg1;
15409   arg2 = (enum Dali::Property::Key::Type)jarg2;
15410   if (arg1) (arg1)->type = arg2;
15411 }
15412
15413
15414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15415   int jresult ;
15416   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15417   enum Dali::Property::Key::Type result;
15418
15419   arg1 = (Dali::Property::Key *)jarg1;
15420   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15421   jresult = (int)result;
15422   return jresult;
15423 }
15424
15425
15426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15427   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15428   Dali::Property::Index arg2 ;
15429
15430   arg1 = (Dali::Property::Key *)jarg1;
15431   arg2 = (Dali::Property::Index)jarg2;
15432   if (arg1) (arg1)->indexKey = arg2;
15433 }
15434
15435
15436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15437   int jresult ;
15438   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15439   Dali::Property::Index result;
15440
15441   arg1 = (Dali::Property::Key *)jarg1;
15442   result = (Dali::Property::Index) ((arg1)->indexKey);
15443   jresult = result;
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15449   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15450   std::string *arg2 = 0 ;
15451
15452   arg1 = (Dali::Property::Key *)jarg1;
15453   if (!jarg2) {
15454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15455     return ;
15456   }
15457   std::string arg2_str(jarg2);
15458   arg2 = &arg2_str;
15459   if (arg1) (arg1)->stringKey = *arg2;
15460
15461   //argout typemap for const std::string&
15462
15463 }
15464
15465
15466 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15467   char * jresult ;
15468   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15469   std::string *result = 0 ;
15470
15471   arg1 = (Dali::Property::Key *)jarg1;
15472   result = (std::string *) & ((arg1)->stringKey);
15473   jresult = SWIG_csharp_string_callback(result->c_str());
15474   return jresult;
15475 }
15476
15477
15478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15479   void * jresult ;
15480   std::string *arg1 = 0 ;
15481   Dali::Property::Key *result = 0 ;
15482
15483   if (!jarg1) {
15484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15485     return 0;
15486   }
15487   std::string arg1_str(jarg1);
15488   arg1 = &arg1_str;
15489   {
15490     try {
15491       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15492     } catch (std::out_of_range& e) {
15493       {
15494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15495       };
15496     } catch (std::exception& e) {
15497       {
15498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15499       };
15500     } catch (Dali::DaliException e) {
15501       {
15502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15503       };
15504     } catch (...) {
15505       {
15506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15507       };
15508     }
15509   }
15510
15511   jresult = (void *)result;
15512
15513   //argout typemap for const std::string&
15514
15515   return jresult;
15516 }
15517
15518
15519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15520   void * jresult ;
15521   Dali::Property::Index arg1 ;
15522   Dali::Property::Key *result = 0 ;
15523
15524   arg1 = (Dali::Property::Index)jarg1;
15525   {
15526     try {
15527       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15528     } catch (std::out_of_range& e) {
15529       {
15530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15531       };
15532     } catch (std::exception& e) {
15533       {
15534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15535       };
15536     } catch (Dali::DaliException e) {
15537       {
15538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15539       };
15540     } catch (...) {
15541       {
15542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15543       };
15544     }
15545   }
15546
15547   jresult = (void *)result;
15548   return jresult;
15549 }
15550
15551
15552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15553   unsigned int jresult ;
15554   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15555   std::string *arg2 = 0 ;
15556   bool result;
15557
15558   arg1 = (Dali::Property::Key *)jarg1;
15559   if (!jarg2) {
15560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15561     return 0;
15562   }
15563   std::string arg2_str(jarg2);
15564   arg2 = &arg2_str;
15565   {
15566     try {
15567       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15568     } catch (std::out_of_range& e) {
15569       {
15570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15571       };
15572     } catch (std::exception& e) {
15573       {
15574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15575       };
15576     } catch (Dali::DaliException e) {
15577       {
15578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15579       };
15580     } catch (...) {
15581       {
15582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15583       };
15584     }
15585   }
15586
15587   jresult = result;
15588
15589   //argout typemap for const std::string&
15590
15591   return jresult;
15592 }
15593
15594
15595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15596   unsigned int jresult ;
15597   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15598   Dali::Property::Index arg2 ;
15599   bool result;
15600
15601   arg1 = (Dali::Property::Key *)jarg1;
15602   arg2 = (Dali::Property::Index)jarg2;
15603   {
15604     try {
15605       result = (bool)(arg1)->operator ==(arg2);
15606     } catch (std::out_of_range& e) {
15607       {
15608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15609       };
15610     } catch (std::exception& e) {
15611       {
15612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15613       };
15614     } catch (Dali::DaliException e) {
15615       {
15616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15617       };
15618     } catch (...) {
15619       {
15620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15621       };
15622     }
15623   }
15624
15625   jresult = result;
15626   return jresult;
15627 }
15628
15629
15630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15631   unsigned int jresult ;
15632   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15633   Dali::Property::Key *arg2 = 0 ;
15634   bool result;
15635
15636   arg1 = (Dali::Property::Key *)jarg1;
15637   arg2 = (Dali::Property::Key *)jarg2;
15638   if (!arg2) {
15639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15640     return 0;
15641   }
15642   {
15643     try {
15644       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15645     } catch (std::out_of_range& e) {
15646       {
15647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15648       };
15649     } catch (std::exception& e) {
15650       {
15651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15652       };
15653     } catch (Dali::DaliException e) {
15654       {
15655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15656       };
15657     } catch (...) {
15658       {
15659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15660       };
15661     }
15662   }
15663
15664   jresult = result;
15665   return jresult;
15666 }
15667
15668
15669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15670   unsigned int jresult ;
15671   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15672   std::string *arg2 = 0 ;
15673   bool result;
15674
15675   arg1 = (Dali::Property::Key *)jarg1;
15676   if (!jarg2) {
15677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15678     return 0;
15679   }
15680   std::string arg2_str(jarg2);
15681   arg2 = &arg2_str;
15682   {
15683     try {
15684       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15685     } catch (std::out_of_range& e) {
15686       {
15687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15688       };
15689     } catch (std::exception& e) {
15690       {
15691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15692       };
15693     } catch (Dali::DaliException e) {
15694       {
15695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15696       };
15697     } catch (...) {
15698       {
15699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15700       };
15701     }
15702   }
15703
15704   jresult = result;
15705
15706   //argout typemap for const std::string&
15707
15708   return jresult;
15709 }
15710
15711
15712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15713   unsigned int jresult ;
15714   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15715   Dali::Property::Index arg2 ;
15716   bool result;
15717
15718   arg1 = (Dali::Property::Key *)jarg1;
15719   arg2 = (Dali::Property::Index)jarg2;
15720   {
15721     try {
15722       result = (bool)(arg1)->operator !=(arg2);
15723     } catch (std::out_of_range& e) {
15724       {
15725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15726       };
15727     } catch (std::exception& e) {
15728       {
15729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15730       };
15731     } catch (Dali::DaliException e) {
15732       {
15733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15734       };
15735     } catch (...) {
15736       {
15737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15738       };
15739     }
15740   }
15741
15742   jresult = result;
15743   return jresult;
15744 }
15745
15746
15747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15748   unsigned int jresult ;
15749   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15750   Dali::Property::Key *arg2 = 0 ;
15751   bool result;
15752
15753   arg1 = (Dali::Property::Key *)jarg1;
15754   arg2 = (Dali::Property::Key *)jarg2;
15755   if (!arg2) {
15756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15757     return 0;
15758   }
15759   {
15760     try {
15761       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15762     } catch (std::out_of_range& e) {
15763       {
15764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15765       };
15766     } catch (std::exception& e) {
15767       {
15768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15769       };
15770     } catch (Dali::DaliException e) {
15771       {
15772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15773       };
15774     } catch (...) {
15775       {
15776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15777       };
15778     }
15779   }
15780
15781   jresult = result;
15782   return jresult;
15783 }
15784
15785
15786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15787   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15788
15789   arg1 = (Dali::Property::Key *)jarg1;
15790   {
15791     try {
15792       delete arg1;
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15800       };
15801     } catch (Dali::DaliException e) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15804       };
15805     } catch (...) {
15806       {
15807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15808       };
15809     }
15810   }
15811
15812 }
15813
15814
15815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15816   void * jresult ;
15817   Dali::Property::Map *result = 0 ;
15818
15819   {
15820     try {
15821       result = (Dali::Property::Map *)new Dali::Property::Map();
15822     } catch (std::out_of_range& e) {
15823       {
15824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15825       };
15826     } catch (std::exception& e) {
15827       {
15828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15829       };
15830     } catch (Dali::DaliException e) {
15831       {
15832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15833       };
15834     } catch (...) {
15835       {
15836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15837       };
15838     }
15839   }
15840
15841   jresult = (void *)result;
15842   return jresult;
15843 }
15844
15845
15846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15847   void * jresult ;
15848   Dali::Property::Map *arg1 = 0 ;
15849   Dali::Property::Map *result = 0 ;
15850
15851   arg1 = (Dali::Property::Map *)jarg1;
15852   if (!arg1) {
15853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15854     return 0;
15855   }
15856   {
15857     try {
15858       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15859     } catch (std::out_of_range& e) {
15860       {
15861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15862       };
15863     } catch (std::exception& e) {
15864       {
15865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15866       };
15867     } catch (Dali::DaliException e) {
15868       {
15869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15870       };
15871     } catch (...) {
15872       {
15873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15874       };
15875     }
15876   }
15877
15878   jresult = (void *)result;
15879   return jresult;
15880 }
15881
15882
15883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15884   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15885
15886   arg1 = (Dali::Property::Map *)jarg1;
15887   {
15888     try {
15889       delete arg1;
15890     } catch (std::out_of_range& e) {
15891       {
15892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15893       };
15894     } catch (std::exception& e) {
15895       {
15896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15897       };
15898     } catch (Dali::DaliException e) {
15899       {
15900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15901       };
15902     } catch (...) {
15903       {
15904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15905       };
15906     }
15907   }
15908
15909 }
15910
15911
15912 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15913   unsigned long jresult ;
15914   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15915   Dali::Property::Map::SizeType result;
15916
15917   arg1 = (Dali::Property::Map *)jarg1;
15918   {
15919     try {
15920       result = ((Dali::Property::Map const *)arg1)->Count();
15921     } catch (std::out_of_range& e) {
15922       {
15923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15924       };
15925     } catch (std::exception& e) {
15926       {
15927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15928       };
15929     } catch (Dali::DaliException e) {
15930       {
15931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15932       };
15933     } catch (...) {
15934       {
15935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15936       };
15937     }
15938   }
15939
15940   jresult = (unsigned long)result;
15941   return jresult;
15942 }
15943
15944
15945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15946   unsigned int jresult ;
15947   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15948   bool result;
15949
15950   arg1 = (Dali::Property::Map *)jarg1;
15951   {
15952     try {
15953       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15954     } catch (std::out_of_range& e) {
15955       {
15956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15957       };
15958     } catch (std::exception& e) {
15959       {
15960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15961       };
15962     } catch (Dali::DaliException e) {
15963       {
15964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15965       };
15966     } catch (...) {
15967       {
15968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15969       };
15970     }
15971   }
15972
15973   jresult = result;
15974   return jresult;
15975 }
15976
15977
15978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15979   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15980   char *arg2 = (char *) 0 ;
15981   Dali::Property::Value *arg3 = 0 ;
15982
15983   arg1 = (Dali::Property::Map *)jarg1;
15984   arg2 = (char *)jarg2;
15985   arg3 = (Dali::Property::Value *)jarg3;
15986   if (!arg3) {
15987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15988     return ;
15989   }
15990   {
15991     try {
15992       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15993     } catch (std::out_of_range& e) {
15994       {
15995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15996       };
15997     } catch (std::exception& e) {
15998       {
15999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16000       };
16001     } catch (Dali::DaliException e) {
16002       {
16003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16004       };
16005     } catch (...) {
16006       {
16007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16008       };
16009     }
16010   }
16011
16012 }
16013
16014
16015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16016   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16017   Dali::Property::Index arg2 ;
16018   Dali::Property::Value *arg3 = 0 ;
16019
16020   arg1 = (Dali::Property::Map *)jarg1;
16021   arg2 = (Dali::Property::Index)jarg2;
16022   arg3 = (Dali::Property::Value *)jarg3;
16023   if (!arg3) {
16024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16025     return ;
16026   }
16027   {
16028     try {
16029       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16030     } catch (std::out_of_range& e) {
16031       {
16032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16033       };
16034     } catch (std::exception& e) {
16035       {
16036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16037       };
16038     } catch (Dali::DaliException e) {
16039       {
16040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16041       };
16042     } catch (...) {
16043       {
16044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16045       };
16046     }
16047   }
16048
16049 }
16050
16051
16052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16053   void * jresult ;
16054   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16055   char *arg2 = (char *) 0 ;
16056   Dali::Property::Value *arg3 = 0 ;
16057   Dali::Property::Map *result = 0 ;
16058
16059   arg1 = (Dali::Property::Map *)jarg1;
16060   arg2 = (char *)jarg2;
16061   arg3 = (Dali::Property::Value *)jarg3;
16062   if (!arg3) {
16063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16064     return 0;
16065   }
16066   {
16067     try {
16068       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16069     } catch (std::out_of_range& e) {
16070       {
16071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16072       };
16073     } catch (std::exception& e) {
16074       {
16075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16076       };
16077     } catch (Dali::DaliException e) {
16078       {
16079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16080       };
16081     } catch (...) {
16082       {
16083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16084       };
16085     }
16086   }
16087
16088   jresult = (void *)result;
16089   return jresult;
16090 }
16091
16092
16093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16094   void * jresult ;
16095   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16096   Dali::Property::Index arg2 ;
16097   Dali::Property::Value *arg3 = 0 ;
16098   Dali::Property::Map *result = 0 ;
16099
16100   arg1 = (Dali::Property::Map *)jarg1;
16101   arg2 = (Dali::Property::Index)jarg2;
16102   arg3 = (Dali::Property::Value *)jarg3;
16103   if (!arg3) {
16104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16105     return 0;
16106   }
16107   {
16108     try {
16109       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16110     } catch (std::out_of_range& e) {
16111       {
16112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16113       };
16114     } catch (std::exception& e) {
16115       {
16116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16117       };
16118     } catch (Dali::DaliException e) {
16119       {
16120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16121       };
16122     } catch (...) {
16123       {
16124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16125       };
16126     }
16127   }
16128
16129   jresult = (void *)result;
16130   return jresult;
16131 }
16132
16133
16134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16135   void * jresult ;
16136   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16137   Dali::Property::Map::SizeType arg2 ;
16138   Dali::Property::Value *result = 0 ;
16139
16140   arg1 = (Dali::Property::Map *)jarg1;
16141   arg2 = (Dali::Property::Map::SizeType)jarg2;
16142   {
16143     try {
16144       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16145     } catch (std::out_of_range& e) {
16146       {
16147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16148       };
16149     } catch (std::exception& e) {
16150       {
16151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16152       };
16153     } catch (Dali::DaliException e) {
16154       {
16155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16156       };
16157     } catch (...) {
16158       {
16159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16160       };
16161     }
16162   }
16163
16164   jresult = (void *)result;
16165   return jresult;
16166 }
16167
16168
16169 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16170   char * jresult ;
16171   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16172   Dali::Property::Map::SizeType arg2 ;
16173   std::string *result = 0 ;
16174
16175   arg1 = (Dali::Property::Map *)jarg1;
16176   arg2 = (Dali::Property::Map::SizeType)jarg2;
16177   {
16178     try {
16179       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16180     } catch (std::out_of_range& e) {
16181       {
16182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16183       };
16184     } catch (std::exception& e) {
16185       {
16186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16187       };
16188     } catch (Dali::DaliException e) {
16189       {
16190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16191       };
16192     } catch (...) {
16193       {
16194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16195       };
16196     }
16197   }
16198
16199   jresult = SWIG_csharp_string_callback(result->c_str());
16200   return jresult;
16201 }
16202
16203
16204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16205   void * jresult ;
16206   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16207   Dali::Property::Map::SizeType arg2 ;
16208   SwigValueWrapper< Dali::Property::Key > result;
16209
16210   arg1 = (Dali::Property::Map *)jarg1;
16211   arg2 = (Dali::Property::Map::SizeType)jarg2;
16212   {
16213     try {
16214       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16215     } catch (std::out_of_range& e) {
16216       {
16217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16218       };
16219     } catch (std::exception& e) {
16220       {
16221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16222       };
16223     } catch (Dali::DaliException e) {
16224       {
16225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16226       };
16227     } catch (...) {
16228       {
16229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16230       };
16231     }
16232   }
16233
16234   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16235   return jresult;
16236 }
16237
16238
16239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16240   void * jresult ;
16241   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16242   Dali::Property::Map::SizeType arg2 ;
16243   StringValuePair *result = 0 ;
16244
16245   arg1 = (Dali::Property::Map *)jarg1;
16246   arg2 = (Dali::Property::Map::SizeType)jarg2;
16247   {
16248     try {
16249       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16250     } catch (std::out_of_range& e) {
16251       {
16252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16253       };
16254     } catch (std::exception& e) {
16255       {
16256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16257       };
16258     } catch (Dali::DaliException e) {
16259       {
16260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16261       };
16262     } catch (...) {
16263       {
16264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16265       };
16266     }
16267   }
16268
16269   jresult = (void *)result;
16270   return jresult;
16271 }
16272
16273
16274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16275   void * jresult ;
16276   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16277   char *arg2 = (char *) 0 ;
16278   Dali::Property::Value *result = 0 ;
16279
16280   arg1 = (Dali::Property::Map *)jarg1;
16281   arg2 = (char *)jarg2;
16282   {
16283     try {
16284       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16285     } catch (std::out_of_range& e) {
16286       {
16287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16288       };
16289     } catch (std::exception& e) {
16290       {
16291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16292       };
16293     } catch (Dali::DaliException e) {
16294       {
16295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16296       };
16297     } catch (...) {
16298       {
16299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16300       };
16301     }
16302   }
16303
16304   jresult = (void *)result;
16305   return jresult;
16306 }
16307
16308
16309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16310   void * jresult ;
16311   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16312   Dali::Property::Index arg2 ;
16313   Dali::Property::Value *result = 0 ;
16314
16315   arg1 = (Dali::Property::Map *)jarg1;
16316   arg2 = (Dali::Property::Index)jarg2;
16317   {
16318     try {
16319       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16320     } catch (std::out_of_range& e) {
16321       {
16322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16323       };
16324     } catch (std::exception& e) {
16325       {
16326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16327       };
16328     } catch (Dali::DaliException e) {
16329       {
16330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16331       };
16332     } catch (...) {
16333       {
16334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16335       };
16336     }
16337   }
16338
16339   jresult = (void *)result;
16340   return jresult;
16341 }
16342
16343
16344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16345   void * jresult ;
16346   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16347   Dali::Property::Index arg2 ;
16348   std::string *arg3 = 0 ;
16349   Dali::Property::Value *result = 0 ;
16350
16351   arg1 = (Dali::Property::Map *)jarg1;
16352   arg2 = (Dali::Property::Index)jarg2;
16353   if (!jarg3) {
16354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16355     return 0;
16356   }
16357   std::string arg3_str(jarg3);
16358   arg3 = &arg3_str;
16359   {
16360     try {
16361       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16362     } catch (std::out_of_range& e) {
16363       {
16364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16365       };
16366     } catch (std::exception& e) {
16367       {
16368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16369       };
16370     } catch (Dali::DaliException e) {
16371       {
16372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16373       };
16374     } catch (...) {
16375       {
16376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16377       };
16378     }
16379   }
16380
16381   jresult = (void *)result;
16382
16383   //argout typemap for const std::string&
16384
16385   return jresult;
16386 }
16387
16388
16389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16390   void * jresult ;
16391   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16392   std::string *arg2 = 0 ;
16393   Dali::Property::Type arg3 ;
16394   Dali::Property::Value *result = 0 ;
16395
16396   arg1 = (Dali::Property::Map *)jarg1;
16397   if (!jarg2) {
16398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16399     return 0;
16400   }
16401   std::string arg2_str(jarg2);
16402   arg2 = &arg2_str;
16403   arg3 = (Dali::Property::Type)jarg3;
16404   {
16405     try {
16406       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16407     } catch (std::out_of_range& e) {
16408       {
16409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16410       };
16411     } catch (std::exception& e) {
16412       {
16413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16414       };
16415     } catch (Dali::DaliException e) {
16416       {
16417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16418       };
16419     } catch (...) {
16420       {
16421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16422       };
16423     }
16424   }
16425
16426   jresult = (void *)result;
16427
16428   //argout typemap for const std::string&
16429
16430   return jresult;
16431 }
16432
16433
16434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16435   void * jresult ;
16436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16437   Dali::Property::Index arg2 ;
16438   Dali::Property::Type arg3 ;
16439   Dali::Property::Value *result = 0 ;
16440
16441   arg1 = (Dali::Property::Map *)jarg1;
16442   arg2 = (Dali::Property::Index)jarg2;
16443   arg3 = (Dali::Property::Type)jarg3;
16444   {
16445     try {
16446       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16447     } catch (std::out_of_range& e) {
16448       {
16449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (std::exception& e) {
16452       {
16453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16454       };
16455     } catch (Dali::DaliException e) {
16456       {
16457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16458       };
16459     } catch (...) {
16460       {
16461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16462       };
16463     }
16464   }
16465
16466   jresult = (void *)result;
16467   return jresult;
16468 }
16469
16470
16471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16472   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16473
16474   arg1 = (Dali::Property::Map *)jarg1;
16475   {
16476     try {
16477       (arg1)->Clear();
16478     } catch (std::out_of_range& e) {
16479       {
16480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16481       };
16482     } catch (std::exception& e) {
16483       {
16484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16485       };
16486     } catch (Dali::DaliException e) {
16487       {
16488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16489       };
16490     } catch (...) {
16491       {
16492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16493       };
16494     }
16495   }
16496
16497 }
16498
16499
16500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16501   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16502   Dali::Property::Map *arg2 = 0 ;
16503
16504   arg1 = (Dali::Property::Map *)jarg1;
16505   arg2 = (Dali::Property::Map *)jarg2;
16506   if (!arg2) {
16507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16508     return ;
16509   }
16510   {
16511     try {
16512       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16513     } catch (std::out_of_range& e) {
16514       {
16515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16516       };
16517     } catch (std::exception& e) {
16518       {
16519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16520       };
16521     } catch (Dali::DaliException e) {
16522       {
16523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16528       };
16529     }
16530   }
16531
16532 }
16533
16534
16535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16536   void * jresult ;
16537   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16538   std::string *arg2 = 0 ;
16539   Dali::Property::Value *result = 0 ;
16540
16541   arg1 = (Dali::Property::Map *)jarg1;
16542   if (!jarg2) {
16543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16544     return 0;
16545   }
16546   std::string arg2_str(jarg2);
16547   arg2 = &arg2_str;
16548   {
16549     try {
16550       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (Dali::DaliException e) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16562       };
16563     } catch (...) {
16564       {
16565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16566       };
16567     }
16568   }
16569
16570   jresult = (void *)result;
16571
16572   //argout typemap for const std::string&
16573
16574   return jresult;
16575 }
16576
16577
16578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16579   void * jresult ;
16580   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16581   Dali::Property::Index arg2 ;
16582   Dali::Property::Value *result = 0 ;
16583
16584   arg1 = (Dali::Property::Map *)jarg1;
16585   arg2 = (Dali::Property::Index)jarg2;
16586   {
16587     try {
16588       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16589     } catch (std::out_of_range& e) {
16590       {
16591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16592       };
16593     } catch (std::exception& e) {
16594       {
16595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16596       };
16597     } catch (Dali::DaliException e) {
16598       {
16599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16600       };
16601     } catch (...) {
16602       {
16603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16604       };
16605     }
16606   }
16607
16608   jresult = (void *)result;
16609   return jresult;
16610 }
16611
16612
16613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16614   void * jresult ;
16615   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16616   Dali::Property::Map *arg2 = 0 ;
16617   Dali::Property::Map *result = 0 ;
16618
16619   arg1 = (Dali::Property::Map *)jarg1;
16620   arg2 = (Dali::Property::Map *)jarg2;
16621   if (!arg2) {
16622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16623     return 0;
16624   }
16625   {
16626     try {
16627       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16628     } catch (std::out_of_range& e) {
16629       {
16630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16631       };
16632     } catch (std::exception& e) {
16633       {
16634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16635       };
16636     } catch (Dali::DaliException e) {
16637       {
16638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16639       };
16640     } catch (...) {
16641       {
16642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16643       };
16644     }
16645   }
16646
16647   jresult = (void *)result;
16648   return jresult;
16649 }
16650
16651
16652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16653
16654   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16655
16656   if (!jarg2) {
16657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16658     return;
16659   }
16660   std::string arg2_str(jarg2);
16661   std::string* arg2 = &arg2_str;
16662
16663   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16664
16665   {
16666     try {
16667       arg1->operator[]((std::string const &)*arg2) = *arg3;
16668     } catch (std::out_of_range& e) {
16669       {
16670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16671       };
16672     } catch (std::exception& e) {
16673       {
16674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16675       };
16676     } catch (Dali::DaliException e) {
16677       {
16678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16679       };
16680     } catch (...) {
16681       {
16682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16683       };
16684     }
16685   }
16686 }
16687
16688
16689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16690
16691   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16692   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16693   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16694
16695   {
16696     try {
16697       arg1->operator[](arg2) = *arg3;
16698     } catch (std::out_of_range& e) {
16699       {
16700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16701       };
16702     } catch (std::exception& e) {
16703       {
16704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16705       };
16706     } catch (Dali::DaliException e) {
16707       {
16708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16709       };
16710     } catch (...) {
16711       {
16712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16713       };
16714     }
16715   }
16716 }
16717
16718
16719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16720   void * jresult ;
16721   Dali::Property::Value *result = 0 ;
16722
16723   {
16724     try {
16725       result = (Dali::Property::Value *)new Dali::Property::Value();
16726     } catch (std::out_of_range& e) {
16727       {
16728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16729       };
16730     } catch (std::exception& e) {
16731       {
16732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16733       };
16734     } catch (Dali::DaliException e) {
16735       {
16736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16737       };
16738     } catch (...) {
16739       {
16740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16741       };
16742     }
16743   }
16744
16745   jresult = (void *)result;
16746   return jresult;
16747 }
16748
16749
16750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16751   void * jresult ;
16752   bool arg1 ;
16753   Dali::Property::Value *result = 0 ;
16754
16755   arg1 = jarg1 ? true : false;
16756   {
16757     try {
16758       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16759     } catch (std::out_of_range& e) {
16760       {
16761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16762       };
16763     } catch (std::exception& e) {
16764       {
16765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16766       };
16767     } catch (Dali::DaliException e) {
16768       {
16769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16770       };
16771     } catch (...) {
16772       {
16773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16774       };
16775     }
16776   }
16777
16778   jresult = (void *)result;
16779   return jresult;
16780 }
16781
16782
16783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16784   void * jresult ;
16785   int arg1 ;
16786   Dali::Property::Value *result = 0 ;
16787
16788   arg1 = (int)jarg1;
16789   {
16790     try {
16791       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16792     } catch (std::out_of_range& e) {
16793       {
16794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (std::exception& e) {
16797       {
16798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16799       };
16800     } catch (Dali::DaliException e) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16803       };
16804     } catch (...) {
16805       {
16806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16807       };
16808     }
16809   }
16810
16811   jresult = (void *)result;
16812   return jresult;
16813 }
16814
16815
16816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16817   void * jresult ;
16818   float arg1 ;
16819   Dali::Property::Value *result = 0 ;
16820
16821   arg1 = (float)jarg1;
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector2 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector2 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16887   void * jresult ;
16888   Dali::Vector3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Vector3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16924   void * jresult ;
16925   Dali::Vector4 *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Vector4 *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16961   void * jresult ;
16962   Dali::Matrix3 *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Matrix3 *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16998   void * jresult ;
16999   Dali::Matrix *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::Matrix *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17035   void * jresult ;
17036   Dali::Rect< int > *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Rect< int > *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17072   void * jresult ;
17073   Dali::AngleAxis *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   arg1 = (Dali::AngleAxis *)jarg1;
17077   if (!arg1) {
17078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17079     return 0;
17080   }
17081   {
17082     try {
17083       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17084     } catch (std::out_of_range& e) {
17085       {
17086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17087       };
17088     } catch (std::exception& e) {
17089       {
17090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17091       };
17092     } catch (Dali::DaliException e) {
17093       {
17094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17095       };
17096     } catch (...) {
17097       {
17098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17099       };
17100     }
17101   }
17102
17103   jresult = (void *)result;
17104   return jresult;
17105 }
17106
17107
17108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17109   void * jresult ;
17110   Dali::Quaternion *arg1 = 0 ;
17111   Dali::Property::Value *result = 0 ;
17112
17113   arg1 = (Dali::Quaternion *)jarg1;
17114   if (!arg1) {
17115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17116     return 0;
17117   }
17118   {
17119     try {
17120       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17121     } catch (std::out_of_range& e) {
17122       {
17123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17124       };
17125     } catch (std::exception& e) {
17126       {
17127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (Dali::DaliException e) {
17130       {
17131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139
17140   jresult = (void *)result;
17141   return jresult;
17142 }
17143
17144
17145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17146   void * jresult ;
17147   std::string *arg1 = 0 ;
17148   Dali::Property::Value *result = 0 ;
17149
17150   if (!jarg1) {
17151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17152     return 0;
17153   }
17154   std::string arg1_str(jarg1);
17155   arg1 = &arg1_str;
17156   {
17157     try {
17158       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (Dali::DaliException e) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177
17178   jresult = (void *)result;
17179
17180   //argout typemap for const std::string&
17181
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17187   void * jresult ;
17188   Dali::Property::Array *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Dali::Property::Array *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (Dali::DaliException e) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17210       };
17211     } catch (...) {
17212       {
17213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17214       };
17215     }
17216   }
17217
17218   jresult = (void *)result;
17219   return jresult;
17220 }
17221
17222
17223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17224   void * jresult ;
17225   Dali::Property::Map *arg1 = 0 ;
17226   Dali::Property::Value *result = 0 ;
17227
17228   arg1 = (Dali::Property::Map *)jarg1;
17229   if (!arg1) {
17230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17231     return 0;
17232   }
17233   {
17234     try {
17235       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17236     } catch (std::out_of_range& e) {
17237       {
17238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17239       };
17240     } catch (std::exception& e) {
17241       {
17242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17243       };
17244     } catch (Dali::DaliException e) {
17245       {
17246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17247       };
17248     } catch (...) {
17249       {
17250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17251       };
17252     }
17253   }
17254
17255   jresult = (void *)result;
17256   return jresult;
17257 }
17258
17259
17260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17261   void * jresult ;
17262   Extents *arg1 = 0 ;
17263   Dali::Property::Value *result = 0 ;
17264
17265   arg1 = (Extents *)jarg1;
17266   if (!arg1) {
17267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17268     return 0;
17269   }
17270   {
17271     try {
17272       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17273     } catch (std::out_of_range& e) {
17274       {
17275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (std::exception& e) {
17278       {
17279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (...) {
17282       {
17283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17284       };
17285     }
17286   }
17287   jresult = (void *)result;
17288   return jresult;
17289 }
17290
17291
17292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17293   void * jresult ;
17294   Dali::Property::Type arg1 ;
17295   Dali::Property::Value *result = 0 ;
17296
17297   arg1 = (Dali::Property::Type)jarg1;
17298   {
17299     try {
17300       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17301     } catch (std::out_of_range& e) {
17302       {
17303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (std::exception& e) {
17306       {
17307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (Dali::DaliException e) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17312       };
17313     } catch (...) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17316       };
17317     }
17318   }
17319
17320   jresult = (void *)result;
17321   return jresult;
17322 }
17323
17324
17325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17326   void * jresult ;
17327   Dali::Property::Value *arg1 = 0 ;
17328   Dali::Property::Value *result = 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   if (!arg1) {
17332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17333     return 0;
17334   }
17335   {
17336     try {
17337       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17338     } catch (std::out_of_range& e) {
17339       {
17340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17341       };
17342     } catch (std::exception& e) {
17343       {
17344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17345       };
17346     } catch (Dali::DaliException e) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17349       };
17350     } catch (...) {
17351       {
17352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17353       };
17354     }
17355   }
17356
17357   jresult = (void *)result;
17358   return jresult;
17359 }
17360
17361
17362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17363   void * jresult ;
17364   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17365   Dali::Property::Value *arg2 = 0 ;
17366   Dali::Property::Value *result = 0 ;
17367
17368   arg1 = (Dali::Property::Value *)jarg1;
17369   arg2 = (Dali::Property::Value *)jarg2;
17370   if (!arg2) {
17371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17372     return 0;
17373   }
17374   {
17375     try {
17376       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17377     } catch (std::out_of_range& e) {
17378       {
17379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17380       };
17381     } catch (std::exception& e) {
17382       {
17383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17384       };
17385     } catch (Dali::DaliException e) {
17386       {
17387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17388       };
17389     } catch (...) {
17390       {
17391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17392       };
17393     }
17394   }
17395
17396   jresult = (void *)result;
17397   return jresult;
17398 }
17399
17400
17401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17402   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17403
17404   arg1 = (Dali::Property::Value *)jarg1;
17405   {
17406     try {
17407       delete arg1;
17408     } catch (std::out_of_range& e) {
17409       {
17410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17411       };
17412     } catch (std::exception& e) {
17413       {
17414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17415       };
17416     } catch (Dali::DaliException e) {
17417       {
17418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17419       };
17420     } catch (...) {
17421       {
17422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17423       };
17424     }
17425   }
17426
17427 }
17428
17429
17430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17431   int jresult ;
17432   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17433   Dali::Property::Type result;
17434
17435   arg1 = (Dali::Property::Value *)jarg1;
17436   {
17437     try {
17438       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17439     } catch (std::out_of_range& e) {
17440       {
17441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (std::exception& e) {
17444       {
17445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17446       };
17447     } catch (Dali::DaliException e) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17450       };
17451     } catch (...) {
17452       {
17453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17454       };
17455     }
17456   }
17457
17458   jresult = (int)result;
17459   return jresult;
17460 }
17461
17462
17463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17464   unsigned int jresult ;
17465   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17466   bool *arg2 = 0 ;
17467   bool result;
17468
17469   arg1 = (Dali::Property::Value *)jarg1;
17470   arg2 = (bool *)jarg2;
17471   {
17472     try {
17473       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17474     } catch (std::out_of_range& e) {
17475       {
17476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (std::exception& e) {
17479       {
17480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17481       };
17482     } catch (Dali::DaliException e) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17485       };
17486     } catch (...) {
17487       {
17488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17489       };
17490     }
17491   }
17492
17493   jresult = result;
17494   return jresult;
17495 }
17496
17497
17498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17499   unsigned int jresult ;
17500   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17501   float *arg2 = 0 ;
17502   bool result;
17503
17504   arg1 = (Dali::Property::Value *)jarg1;
17505   arg2 = (float *)jarg2;
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   int *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (int *)jarg2;
17541   {
17542     try {
17543       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17544     } catch (std::out_of_range& e) {
17545       {
17546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (std::exception& e) {
17549       {
17550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (Dali::DaliException e) {
17553       {
17554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17555       };
17556     } catch (...) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17559       };
17560     }
17561   }
17562
17563   jresult = result;
17564   return jresult;
17565 }
17566
17567
17568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17569   unsigned int jresult ;
17570   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17571   Dali::Rect< int > *arg2 = 0 ;
17572   bool result;
17573
17574   arg1 = (Dali::Property::Value *)jarg1;
17575   arg2 = (Dali::Rect< int > *)jarg2;
17576   if (!arg2) {
17577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17578     return 0;
17579   }
17580   {
17581     try {
17582       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17583     } catch (std::out_of_range& e) {
17584       {
17585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17586       };
17587     } catch (std::exception& e) {
17588       {
17589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (Dali::DaliException e) {
17592       {
17593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17594       };
17595     } catch (...) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17598       };
17599     }
17600   }
17601
17602   jresult = result;
17603   return jresult;
17604 }
17605
17606
17607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17608   unsigned int jresult ;
17609   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17610   Dali::Vector2 *arg2 = 0 ;
17611   bool result;
17612
17613   arg1 = (Dali::Property::Value *)jarg1;
17614   arg2 = (Dali::Vector2 *)jarg2;
17615   if (!arg2) {
17616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17617     return 0;
17618   }
17619   {
17620     try {
17621       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17622     } catch (std::out_of_range& e) {
17623       {
17624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17625       };
17626     } catch (std::exception& e) {
17627       {
17628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (Dali::DaliException e) {
17631       {
17632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17633       };
17634     } catch (...) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17637       };
17638     }
17639   }
17640
17641   jresult = result;
17642   return jresult;
17643 }
17644
17645
17646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17647   unsigned int jresult ;
17648   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17649   Dali::Vector3 *arg2 = 0 ;
17650   bool result;
17651
17652   arg1 = (Dali::Property::Value *)jarg1;
17653   arg2 = (Dali::Vector3 *)jarg2;
17654   if (!arg2) {
17655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17656     return 0;
17657   }
17658   {
17659     try {
17660       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (Dali::DaliException e) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17672       };
17673     } catch (...) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17676       };
17677     }
17678   }
17679
17680   jresult = result;
17681   return jresult;
17682 }
17683
17684
17685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17686   unsigned int jresult ;
17687   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17688   Dali::Vector4 *arg2 = 0 ;
17689   bool result;
17690
17691   arg1 = (Dali::Property::Value *)jarg1;
17692   arg2 = (Dali::Vector4 *)jarg2;
17693   if (!arg2) {
17694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17695     return 0;
17696   }
17697   {
17698     try {
17699       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17700     } catch (std::out_of_range& e) {
17701       {
17702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17703       };
17704     } catch (std::exception& e) {
17705       {
17706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (Dali::DaliException e) {
17709       {
17710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17711       };
17712     } catch (...) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17715       };
17716     }
17717   }
17718
17719   jresult = result;
17720   return jresult;
17721 }
17722
17723
17724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17725   unsigned int jresult ;
17726   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17727   Dali::Matrix3 *arg2 = 0 ;
17728   bool result;
17729
17730   arg1 = (Dali::Property::Value *)jarg1;
17731   arg2 = (Dali::Matrix3 *)jarg2;
17732   if (!arg2) {
17733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17734     return 0;
17735   }
17736   {
17737     try {
17738       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17739     } catch (std::out_of_range& e) {
17740       {
17741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (std::exception& e) {
17744       {
17745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (Dali::DaliException e) {
17748       {
17749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757
17758   jresult = result;
17759   return jresult;
17760 }
17761
17762
17763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17764   unsigned int jresult ;
17765   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17766   Dali::Matrix *arg2 = 0 ;
17767   bool result;
17768
17769   arg1 = (Dali::Property::Value *)jarg1;
17770   arg2 = (Dali::Matrix *)jarg2;
17771   if (!arg2) {
17772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17773     return 0;
17774   }
17775   {
17776     try {
17777       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17778     } catch (std::out_of_range& e) {
17779       {
17780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17781       };
17782     } catch (std::exception& e) {
17783       {
17784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (Dali::DaliException e) {
17787       {
17788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17789       };
17790     } catch (...) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17793       };
17794     }
17795   }
17796
17797   jresult = result;
17798   return jresult;
17799 }
17800
17801
17802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17803   unsigned int jresult ;
17804   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17805   Dali::AngleAxis *arg2 = 0 ;
17806   bool result;
17807
17808   arg1 = (Dali::Property::Value *)jarg1;
17809   arg2 = (Dali::AngleAxis *)jarg2;
17810   if (!arg2) {
17811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17812     return 0;
17813   }
17814   {
17815     try {
17816       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (Dali::DaliException e) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17828       };
17829     } catch (...) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17832       };
17833     }
17834   }
17835
17836   jresult = result;
17837   return jresult;
17838 }
17839
17840
17841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17842   unsigned int jresult ;
17843   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17844   Dali::Quaternion *arg2 = 0 ;
17845   bool result;
17846
17847   arg1 = (Dali::Property::Value *)jarg1;
17848   arg2 = (Dali::Quaternion *)jarg2;
17849   if (!arg2) {
17850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17851     return 0;
17852   }
17853   {
17854     try {
17855       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17856     } catch (std::out_of_range& e) {
17857       {
17858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17859       };
17860     } catch (std::exception& e) {
17861       {
17862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17863       };
17864     } catch (Dali::DaliException e) {
17865       {
17866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17867       };
17868     } catch (...) {
17869       {
17870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17871       };
17872     }
17873   }
17874
17875   jresult = result;
17876   return jresult;
17877 }
17878
17879
17880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17881   unsigned int jresult ;
17882   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17883   std::string *arg2 = 0 ;
17884   bool result;
17885
17886   arg1 = (Dali::Property::Value *)jarg1;
17887
17888   //typemap in
17889   std::string temp;
17890   arg2 = &temp;
17891
17892   {
17893     try {
17894       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17895     } catch (std::out_of_range& e) {
17896       {
17897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17898       };
17899     } catch (std::exception& e) {
17900       {
17901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (Dali::DaliException e) {
17904       {
17905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17906       };
17907     } catch (...) {
17908       {
17909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17910       };
17911     }
17912   }
17913
17914   jresult = result;
17915
17916   //Typemap argout in c++ file.
17917   //This will convert c++ string to c# string
17918   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17919
17920   return jresult;
17921 }
17922
17923
17924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17925   unsigned int jresult ;
17926   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17927   Dali::Property::Array *arg2 = 0 ;
17928   bool result;
17929
17930   arg1 = (Dali::Property::Value *)jarg1;
17931   arg2 = (Dali::Property::Array *)jarg2;
17932   if (!arg2) {
17933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17934     return 0;
17935   }
17936   {
17937     try {
17938       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17939     } catch (std::out_of_range& e) {
17940       {
17941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17942       };
17943     } catch (std::exception& e) {
17944       {
17945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (Dali::DaliException e) {
17948       {
17949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957
17958   jresult = result;
17959   return jresult;
17960 }
17961
17962
17963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17964   unsigned int jresult ;
17965   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17966   Dali::Property::Map *arg2 = 0 ;
17967   bool result;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   arg2 = (Dali::Property::Map *)jarg2;
17971   if (!arg2) {
17972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17973     return 0;
17974   }
17975   {
17976     try {
17977       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17978     } catch (std::out_of_range& e) {
17979       {
17980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17981       };
17982     } catch (std::exception& e) {
17983       {
17984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17985       };
17986     } catch (Dali::DaliException e) {
17987       {
17988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17989       };
17990     } catch (...) {
17991       {
17992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17993       };
17994     }
17995   }
17996
17997   jresult = result;
17998   return jresult;
17999 }
18000
18001
18002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
18003   unsigned int jresult ;
18004   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18005   Extents *arg2 = 0 ;
18006   bool result;
18007
18008   arg1 = (Dali::Property::Value *)jarg1;
18009   arg2 = (Extents *)jarg2;
18010   if (!arg2) {
18011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
18012     return 0;
18013   }
18014   {
18015     try {
18016       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
18017     } catch (std::out_of_range& e) {
18018       {
18019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18020       };
18021     } catch (std::exception& e) {
18022       {
18023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18024       };
18025     } catch (...) {
18026       {
18027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18028       };
18029     }
18030   }
18031   jresult = result;
18032   return jresult;
18033 }
18034
18035
18036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18037   void * jresult ;
18038   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18039   Dali::Property::Array *result = 0 ;
18040
18041   arg1 = (Dali::Property::Value *)jarg1;
18042   {
18043     try {
18044       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18045     } catch (std::out_of_range& e) {
18046       {
18047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18048       };
18049     } catch (std::exception& e) {
18050       {
18051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18052       };
18053     } catch (Dali::DaliException e) {
18054       {
18055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18056       };
18057     } catch (...) {
18058       {
18059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18060       };
18061     }
18062   }
18063
18064   jresult = (void *)result;
18065   return jresult;
18066 }
18067
18068
18069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18070   void * jresult ;
18071   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18072   Dali::Property::Map *result = 0 ;
18073
18074   arg1 = (Dali::Property::Value *)jarg1;
18075   {
18076     try {
18077       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18078     } catch (std::out_of_range& e) {
18079       {
18080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18081       };
18082     } catch (std::exception& e) {
18083       {
18084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18085       };
18086     } catch (Dali::DaliException e) {
18087       {
18088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18089       };
18090     } catch (...) {
18091       {
18092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18093       };
18094     }
18095   }
18096
18097   jresult = (void *)result;
18098   return jresult;
18099 }
18100
18101
18102 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18103   char * jresult ;
18104   Dali::Property::Type arg1 ;
18105   char *result = 0 ;
18106
18107   arg1 = (Dali::Property::Type)jarg1;
18108   {
18109     try {
18110       result = (char *)Dali::PropertyTypes::GetName(arg1);
18111     } catch (std::out_of_range& e) {
18112       {
18113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18114       };
18115     } catch (std::exception& e) {
18116       {
18117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (Dali::DaliException e) {
18120       {
18121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18122       };
18123     } catch (...) {
18124       {
18125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18126       };
18127     }
18128   }
18129
18130   jresult = SWIG_csharp_string_callback((const char *)result);
18131   return jresult;
18132 }
18133
18134
18135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18136   unsigned int jresult ;
18137   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18138   std::string *arg2 = 0 ;
18139   Dali::Property::Map *arg3 = 0 ;
18140   bool result;
18141
18142   arg1 = (Dali::BaseObject *)jarg1;
18143   if (!jarg2) {
18144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18145     return 0;
18146   }
18147   std::string arg2_str(jarg2);
18148   arg2 = &arg2_str;
18149   arg3 = (Dali::Property::Map *)jarg3;
18150   if (!arg3) {
18151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18152     return 0;
18153   }
18154   {
18155     try {
18156       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18157     } catch (std::out_of_range& e) {
18158       {
18159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18160       };
18161     } catch (std::exception& e) {
18162       {
18163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18164       };
18165     } catch (Dali::DaliException e) {
18166       {
18167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18168       };
18169     } catch (...) {
18170       {
18171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18172       };
18173     }
18174   }
18175
18176   jresult = result;
18177
18178   //argout typemap for const std::string&
18179
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18185   char * jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   std::string *result = 0 ;
18188
18189   arg1 = (Dali::BaseObject *)jarg1;
18190   {
18191     try {
18192       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18193     } catch (std::out_of_range& e) {
18194       {
18195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18196       };
18197     } catch (std::exception& e) {
18198       {
18199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18200       };
18201     } catch (Dali::DaliException e) {
18202       {
18203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18204       };
18205     } catch (...) {
18206       {
18207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18208       };
18209     }
18210   }
18211
18212   jresult = SWIG_csharp_string_callback(result->c_str());
18213   return jresult;
18214 }
18215
18216
18217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18218   unsigned int jresult ;
18219   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18220   Dali::TypeInfo *arg2 = 0 ;
18221   bool result;
18222
18223   arg1 = (Dali::BaseObject *)jarg1;
18224   arg2 = (Dali::TypeInfo *)jarg2;
18225   if (!arg2) {
18226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18227     return 0;
18228   }
18229   {
18230     try {
18231       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18232     } catch (std::out_of_range& e) {
18233       {
18234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18235       };
18236     } catch (std::exception& e) {
18237       {
18238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (Dali::DaliException e) {
18241       {
18242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18243       };
18244     } catch (...) {
18245       {
18246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18247       };
18248     }
18249   }
18250
18251   jresult = result;
18252   return jresult;
18253 }
18254
18255
18256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18257   unsigned int jresult ;
18258   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18259   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18260   std::string *arg3 = 0 ;
18261   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18262   bool result;
18263
18264   arg1 = (Dali::BaseObject *)jarg1;
18265   arg2 = (ConnectionTrackerInterface *)jarg2;
18266   if (!jarg3) {
18267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18268     return 0;
18269   }
18270   std::string arg3_str(jarg3);
18271   arg3 = &arg3_str;
18272   arg4 = (FunctorDelegate *)jarg4;
18273   {
18274     try {
18275       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18276     } catch (std::out_of_range& e) {
18277       {
18278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18279       };
18280     } catch (std::exception& e) {
18281       {
18282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18283       };
18284     } catch (Dali::DaliException e) {
18285       {
18286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18287       };
18288     } catch (...) {
18289       {
18290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18291       };
18292     }
18293   }
18294
18295   jresult = result;
18296
18297   //argout typemap for const std::string&
18298
18299   return jresult;
18300 }
18301
18302
18303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18304   void * jresult ;
18305   Dali::BaseHandle *arg1 = 0 ;
18306   Dali::BaseObject *result = 0 ;
18307
18308   arg1 = (Dali::BaseHandle *)jarg1;
18309   if (!arg1) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18311     return 0;
18312   }
18313   {
18314     try {
18315       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18316     } catch (std::out_of_range& e) {
18317       {
18318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (std::exception& e) {
18321       {
18322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18323       };
18324     } catch (Dali::DaliException e) {
18325       {
18326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18327       };
18328     } catch (...) {
18329       {
18330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18331       };
18332     }
18333   }
18334
18335   jresult = (void *)result;
18336   return jresult;
18337 }
18338
18339
18340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18341   void * jresult ;
18342   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18343   Dali::BaseHandle *result = 0 ;
18344
18345   arg1 = (Dali::BaseObject *)jarg1;
18346   {
18347     try {
18348       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18349     } catch (std::out_of_range& e) {
18350       {
18351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18352       };
18353     } catch (std::exception& e) {
18354       {
18355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18356       };
18357     } catch (Dali::DaliException e) {
18358       {
18359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18360       };
18361     } catch (...) {
18362       {
18363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18364       };
18365     }
18366   }
18367
18368   jresult = (void *)result;
18369   return jresult;
18370 }
18371
18372
18373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18374   void * jresult ;
18375   Dali::BaseHandle *result = 0 ;
18376
18377   {
18378     try {
18379       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18380     } catch (std::out_of_range& e) {
18381       {
18382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18383       };
18384     } catch (std::exception& e) {
18385       {
18386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18387       };
18388     } catch (Dali::DaliException e) {
18389       {
18390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18391       };
18392     } catch (...) {
18393       {
18394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18395       };
18396     }
18397   }
18398
18399   jresult = (void *)result;
18400   return jresult;
18401 }
18402
18403
18404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18405   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18406
18407   arg1 = (Dali::BaseHandle *)jarg1;
18408   {
18409     try {
18410       delete arg1;
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18426       };
18427     }
18428   }
18429
18430 }
18431
18432
18433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18434   void * jresult ;
18435   Dali::BaseHandle *arg1 = 0 ;
18436   Dali::BaseHandle *result = 0 ;
18437
18438   arg1 = (Dali::BaseHandle *)jarg1;
18439   if (!arg1) {
18440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18441     return 0;
18442   }
18443   {
18444     try {
18445       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18446     } catch (std::out_of_range& e) {
18447       {
18448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18449       };
18450     } catch (std::exception& e) {
18451       {
18452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18453       };
18454     } catch (Dali::DaliException e) {
18455       {
18456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18457       };
18458     } catch (...) {
18459       {
18460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18461       };
18462     }
18463   }
18464
18465   jresult = (void *)result;
18466   return jresult;
18467 }
18468
18469
18470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18471   void * jresult ;
18472   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18473   Dali::BaseHandle *arg2 = 0 ;
18474   Dali::BaseHandle *result = 0 ;
18475
18476   arg1 = (Dali::BaseHandle *)jarg1;
18477   arg2 = (Dali::BaseHandle *)jarg2;
18478   if (!arg2) {
18479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18480     return 0;
18481   }
18482   {
18483     try {
18484       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18485     } catch (std::out_of_range& e) {
18486       {
18487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18488       };
18489     } catch (std::exception& e) {
18490       {
18491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18492       };
18493     } catch (Dali::DaliException e) {
18494       {
18495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18496       };
18497     } catch (...) {
18498       {
18499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18500       };
18501     }
18502   }
18503
18504   jresult = (void *)result;
18505   return jresult;
18506 }
18507
18508
18509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18510   unsigned int jresult ;
18511   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18512   std::string *arg2 = 0 ;
18513   Dali::Property::Map *arg3 = 0 ;
18514   bool result;
18515
18516   arg1 = (Dali::BaseHandle *)jarg1;
18517   if (!jarg2) {
18518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18519     return 0;
18520   }
18521   std::string arg2_str(jarg2);
18522   arg2 = &arg2_str;
18523   arg3 = (Dali::Property::Map *)jarg3;
18524   if (!arg3) {
18525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18526     return 0;
18527   }
18528   {
18529     try {
18530       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18538       };
18539     } catch (Dali::DaliException e) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18542       };
18543     } catch (...) {
18544       {
18545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18546       };
18547     }
18548   }
18549
18550   jresult = result;
18551
18552   //argout typemap for const std::string&
18553
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18559   char * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   std::string *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = SWIG_csharp_string_callback(result->c_str());
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18592   unsigned int jresult ;
18593   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18594   Dali::TypeInfo *arg2 = 0 ;
18595   bool result;
18596
18597   arg1 = (Dali::BaseHandle *)jarg1;
18598   arg2 = (Dali::TypeInfo *)jarg2;
18599   if (!arg2) {
18600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18601     return 0;
18602   }
18603   {
18604     try {
18605       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18606     } catch (std::out_of_range& e) {
18607       {
18608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18609       };
18610     } catch (std::exception& e) {
18611       {
18612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18613       };
18614     } catch (Dali::DaliException e) {
18615       {
18616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18617       };
18618     } catch (...) {
18619       {
18620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18621       };
18622     }
18623   }
18624
18625   jresult = result;
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18631   void * jresult ;
18632   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18633   Dali::BaseObject *result = 0 ;
18634
18635   arg1 = (Dali::BaseHandle *)jarg1;
18636   {
18637     try {
18638       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18639     } catch (std::out_of_range& e) {
18640       {
18641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (std::exception& e) {
18644       {
18645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18646       };
18647     } catch (Dali::DaliException e) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18654       };
18655     }
18656   }
18657
18658   jresult = (void *)result;
18659   return jresult;
18660 }
18661
18662
18663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18664   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18665
18666   arg1 = (Dali::BaseHandle *)jarg1;
18667   {
18668     try {
18669       (arg1)->Reset();
18670     } catch (std::out_of_range& e) {
18671       {
18672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18673       };
18674     } catch (std::exception& e) {
18675       {
18676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18677       };
18678     } catch (Dali::DaliException e) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18681       };
18682     } catch (...) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18685       };
18686     }
18687   }
18688
18689 }
18690
18691
18692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18693   unsigned int jresult ;
18694   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18695   Dali::BaseHandle *arg2 = 0 ;
18696   bool result;
18697
18698   arg1 = (Dali::BaseHandle *)jarg1;
18699   arg2 = (Dali::BaseHandle *)jarg2;
18700   if (!arg2) {
18701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18702     return 0;
18703   }
18704   {
18705     try {
18706       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (Dali::DaliException e) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725
18726   jresult = result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   Dali::BaseHandle *arg2 = 0 ;
18735   bool result;
18736
18737   arg1 = (Dali::BaseHandle *)jarg1;
18738   arg2 = (Dali::BaseHandle *)jarg2;
18739   if (!arg2) {
18740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18741     return 0;
18742   }
18743   {
18744     try {
18745       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18746     } catch (std::out_of_range& e) {
18747       {
18748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18749       };
18750     } catch (std::exception& e) {
18751       {
18752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18753       };
18754     } catch (Dali::DaliException e) {
18755       {
18756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18757       };
18758     } catch (...) {
18759       {
18760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18761       };
18762     }
18763   }
18764
18765   jresult = result;
18766   return jresult;
18767 }
18768
18769
18770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18771   void * jresult ;
18772   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18773   Dali::RefObject *result = 0 ;
18774
18775   arg1 = (Dali::BaseHandle *)jarg1;
18776   {
18777     try {
18778       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18779     } catch (std::out_of_range& e) {
18780       {
18781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (std::exception& e) {
18784       {
18785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (Dali::DaliException e) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797
18798   jresult = (void *)result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18806   bool result;
18807
18808   arg1 = (Dali::BaseHandle *)jarg1;
18809   {
18810     try {
18811       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18812     } catch (std::out_of_range& e) {
18813       {
18814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18815       };
18816     } catch (std::exception& e) {
18817       {
18818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18819       };
18820     } catch (Dali::DaliException e) {
18821       {
18822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18823       };
18824     } catch (...) {
18825       {
18826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18827       };
18828     }
18829   }
18830
18831   jresult = result;
18832   return jresult;
18833 }
18834
18835
18836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18837   unsigned int jresult ;
18838   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18839   Dali::BaseHandle *arg2 = 0 ;
18840   bool result;
18841
18842   arg1 = (Dali::BaseHandle *)jarg1;
18843   arg2 = (Dali::BaseHandle *)jarg2;
18844   if (!arg2) {
18845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18846     return 0;
18847   }
18848   {
18849     try {
18850       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18866       };
18867     }
18868   }
18869
18870   jresult = result;
18871   return jresult;
18872 }
18873
18874
18875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18876   unsigned int jresult ;
18877   Dali::BaseHandle *arg1 = 0 ;
18878   Dali::BaseHandle *arg2 = 0 ;
18879   bool result;
18880
18881   arg1 = (Dali::BaseHandle *)jarg1;
18882   if (!arg1) {
18883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18884     return 0;
18885   }
18886   arg2 = (Dali::BaseHandle *)jarg2;
18887   if (!arg2) {
18888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18889     return 0;
18890   }
18891   {
18892     try {
18893       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18894     } catch (std::out_of_range& e) {
18895       {
18896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18897       };
18898     } catch (std::exception& e) {
18899       {
18900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18901       };
18902     } catch (Dali::DaliException e) {
18903       {
18904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18905       };
18906     } catch (...) {
18907       {
18908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18909       };
18910     }
18911   }
18912
18913   jresult = result;
18914   return jresult;
18915 }
18916
18917
18918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18919   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18920
18921   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18922   {
18923     try {
18924       delete arg1;
18925     } catch (std::out_of_range& e) {
18926       {
18927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18928       };
18929     } catch (std::exception& e) {
18930       {
18931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18932       };
18933     } catch (Dali::DaliException e) {
18934       {
18935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18936       };
18937     } catch (...) {
18938       {
18939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18940       };
18941     }
18942   }
18943
18944 }
18945
18946
18947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18948   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18949   SlotObserver *arg2 = (SlotObserver *) 0 ;
18950   CallbackBase *arg3 = (CallbackBase *) 0 ;
18951
18952   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18953   arg2 = (SlotObserver *)jarg2;
18954   arg3 = (CallbackBase *)jarg3;
18955   {
18956     try {
18957       (arg1)->SignalConnected(arg2,arg3);
18958     } catch (std::out_of_range& e) {
18959       {
18960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18961       };
18962     } catch (std::exception& e) {
18963       {
18964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18965       };
18966     } catch (Dali::DaliException e) {
18967       {
18968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18969       };
18970     } catch (...) {
18971       {
18972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18973       };
18974     }
18975   }
18976
18977 }
18978
18979
18980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18981   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18982
18983   arg1 = (Dali::SignalObserver *)jarg1;
18984   {
18985     try {
18986       delete arg1;
18987     } catch (std::out_of_range& e) {
18988       {
18989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18990       };
18991     } catch (std::exception& e) {
18992       {
18993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18994       };
18995     } catch (Dali::DaliException e) {
18996       {
18997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18998       };
18999     } catch (...) {
19000       {
19001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19002       };
19003     }
19004   }
19005
19006 }
19007
19008
19009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19010   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
19011   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19012   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19013
19014   arg1 = (Dali::SignalObserver *)jarg1;
19015   arg2 = (Dali::SlotObserver *)jarg2;
19016   arg3 = (Dali::CallbackBase *)jarg3;
19017   {
19018     try {
19019       (arg1)->SignalDisconnected(arg2,arg3);
19020     } catch (std::out_of_range& e) {
19021       {
19022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19023       };
19024     } catch (std::exception& e) {
19025       {
19026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19027       };
19028     } catch (Dali::DaliException e) {
19029       {
19030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19031       };
19032     } catch (...) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19035       };
19036     }
19037   }
19038
19039 }
19040
19041
19042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19043   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19044
19045   arg1 = (Dali::SlotObserver *)jarg1;
19046   {
19047     try {
19048       delete arg1;
19049     } catch (std::out_of_range& e) {
19050       {
19051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19052       };
19053     } catch (std::exception& e) {
19054       {
19055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19056       };
19057     } catch (Dali::DaliException e) {
19058       {
19059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19060       };
19061     } catch (...) {
19062       {
19063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19064       };
19065     }
19066   }
19067
19068 }
19069
19070
19071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19072   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19073   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19074
19075   arg1 = (Dali::SlotObserver *)jarg1;
19076   arg2 = (Dali::CallbackBase *)jarg2;
19077   {
19078     try {
19079       (arg1)->SlotDisconnected(arg2);
19080     } catch (std::out_of_range& e) {
19081       {
19082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19083       };
19084     } catch (std::exception& e) {
19085       {
19086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19087       };
19088     } catch (Dali::DaliException e) {
19089       {
19090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19091       };
19092     } catch (...) {
19093       {
19094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19095       };
19096     }
19097   }
19098
19099 }
19100
19101
19102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19103   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19104
19105   arg1 = (Dali::ConnectionTracker *)jarg1;
19106   {
19107     try {
19108       delete arg1;
19109     } catch (std::out_of_range& e) {
19110       {
19111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19112       };
19113     } catch (std::exception& e) {
19114       {
19115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19116       };
19117     } catch (Dali::DaliException e) {
19118       {
19119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19120       };
19121     } catch (...) {
19122       {
19123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19124       };
19125     }
19126   }
19127
19128 }
19129
19130
19131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19132   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19133
19134   arg1 = (Dali::ConnectionTracker *)jarg1;
19135   {
19136     try {
19137       (arg1)->DisconnectAll();
19138     } catch (std::out_of_range& e) {
19139       {
19140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19141       };
19142     } catch (std::exception& e) {
19143       {
19144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19145       };
19146     } catch (Dali::DaliException e) {
19147       {
19148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19149       };
19150     } catch (...) {
19151       {
19152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19153       };
19154     }
19155   }
19156
19157 }
19158
19159
19160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19161   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19162   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19163   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19164
19165   arg1 = (Dali::ConnectionTracker *)jarg1;
19166   arg2 = (Dali::SlotObserver *)jarg2;
19167   arg3 = (Dali::CallbackBase *)jarg3;
19168   {
19169     try {
19170       (arg1)->SignalConnected(arg2,arg3);
19171     } catch (std::out_of_range& e) {
19172       {
19173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19174       };
19175     } catch (std::exception& e) {
19176       {
19177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19178       };
19179     } catch (Dali::DaliException e) {
19180       {
19181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19182       };
19183     } catch (...) {
19184       {
19185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19186       };
19187     }
19188   }
19189
19190 }
19191
19192
19193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19194   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19195   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19196   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19197
19198   arg1 = (Dali::ConnectionTracker *)jarg1;
19199   arg2 = (Dali::SlotObserver *)jarg2;
19200   arg3 = (Dali::CallbackBase *)jarg3;
19201   {
19202     try {
19203       (arg1)->SignalDisconnected(arg2,arg3);
19204     } catch (std::out_of_range& e) {
19205       {
19206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19207       };
19208     } catch (std::exception& e) {
19209       {
19210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19211       };
19212     } catch (Dali::DaliException e) {
19213       {
19214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19215       };
19216     } catch (...) {
19217       {
19218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19219       };
19220     }
19221   }
19222
19223 }
19224
19225
19226 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19227   unsigned long jresult ;
19228   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19229   std::size_t result;
19230
19231   arg1 = (Dali::ConnectionTracker *)jarg1;
19232   {
19233     try {
19234       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19235     } catch (std::out_of_range& e) {
19236       {
19237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19238       };
19239     } catch (std::exception& e) {
19240       {
19241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19242       };
19243     } catch (Dali::DaliException e) {
19244       {
19245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19246       };
19247     } catch (...) {
19248       {
19249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19250       };
19251     }
19252   }
19253
19254   jresult = (unsigned long)result;
19255   return jresult;
19256 }
19257
19258
19259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19260   void * jresult ;
19261   Dali::ObjectRegistry *result = 0 ;
19262
19263   {
19264     try {
19265       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19266     } catch (std::out_of_range& e) {
19267       {
19268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19269       };
19270     } catch (std::exception& e) {
19271       {
19272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19273       };
19274     } catch (Dali::DaliException e) {
19275       {
19276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19277       };
19278     } catch (...) {
19279       {
19280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19281       };
19282     }
19283   }
19284
19285   jresult = (void *)result;
19286   return jresult;
19287 }
19288
19289
19290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19291   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19292
19293   arg1 = (Dali::ObjectRegistry *)jarg1;
19294   {
19295     try {
19296       delete arg1;
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19312       };
19313     }
19314   }
19315
19316 }
19317
19318
19319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19320   void * jresult ;
19321   Dali::ObjectRegistry *arg1 = 0 ;
19322   Dali::ObjectRegistry *result = 0 ;
19323
19324   arg1 = (Dali::ObjectRegistry *)jarg1;
19325   if (!arg1) {
19326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19327     return 0;
19328   }
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (Dali::DaliException e) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry *arg2 = 0 ;
19360   Dali::ObjectRegistry *result = 0 ;
19361
19362   arg1 = (Dali::ObjectRegistry *)jarg1;
19363   arg2 = (Dali::ObjectRegistry *)jarg2;
19364   if (!arg2) {
19365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19366     return 0;
19367   }
19368   {
19369     try {
19370       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19371     } catch (std::out_of_range& e) {
19372       {
19373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19374       };
19375     } catch (std::exception& e) {
19376       {
19377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19378       };
19379     } catch (Dali::DaliException e) {
19380       {
19381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19382       };
19383     } catch (...) {
19384       {
19385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19386       };
19387     }
19388   }
19389
19390   jresult = (void *)result;
19391   return jresult;
19392 }
19393
19394
19395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19396   void * jresult ;
19397   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19398   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19399
19400   arg1 = (Dali::ObjectRegistry *)jarg1;
19401   {
19402     try {
19403       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19404     } catch (std::out_of_range& e) {
19405       {
19406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19407       };
19408     } catch (std::exception& e) {
19409       {
19410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19411       };
19412     } catch (Dali::DaliException e) {
19413       {
19414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19415       };
19416     } catch (...) {
19417       {
19418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19419       };
19420     }
19421   }
19422
19423   jresult = (void *)result;
19424   return jresult;
19425 }
19426
19427
19428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19429   void * jresult ;
19430   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19431   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19432
19433   arg1 = (Dali::ObjectRegistry *)jarg1;
19434   {
19435     try {
19436       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19437     } catch (std::out_of_range& e) {
19438       {
19439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19440       };
19441     } catch (std::exception& e) {
19442       {
19443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19444       };
19445     } catch (Dali::DaliException e) {
19446       {
19447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19448       };
19449     } catch (...) {
19450       {
19451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19452       };
19453     }
19454   }
19455
19456   jresult = (void *)result;
19457   return jresult;
19458 }
19459
19460
19461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19462   void * jresult ;
19463   Dali::PropertyCondition *result = 0 ;
19464
19465   {
19466     try {
19467       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19468     } catch (std::out_of_range& e) {
19469       {
19470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19471       };
19472     } catch (std::exception& e) {
19473       {
19474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19475       };
19476     } catch (Dali::DaliException e) {
19477       {
19478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19479       };
19480     } catch (...) {
19481       {
19482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19483       };
19484     }
19485   }
19486
19487   jresult = (void *)result;
19488   return jresult;
19489 }
19490
19491
19492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19493   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19494
19495   arg1 = (Dali::PropertyCondition *)jarg1;
19496   {
19497     try {
19498       delete arg1;
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19514       };
19515     }
19516   }
19517
19518 }
19519
19520
19521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19522   void * jresult ;
19523   Dali::PropertyCondition *arg1 = 0 ;
19524   Dali::PropertyCondition *result = 0 ;
19525
19526   arg1 = (Dali::PropertyCondition *)jarg1;
19527   if (!arg1) {
19528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19529     return 0;
19530   }
19531   {
19532     try {
19533       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (Dali::DaliException e) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19545       };
19546     } catch (...) {
19547       {
19548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19549       };
19550     }
19551   }
19552
19553   jresult = (void *)result;
19554   return jresult;
19555 }
19556
19557
19558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19559   void * jresult ;
19560   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19561   Dali::PropertyCondition *arg2 = 0 ;
19562   Dali::PropertyCondition *result = 0 ;
19563
19564   arg1 = (Dali::PropertyCondition *)jarg1;
19565   arg2 = (Dali::PropertyCondition *)jarg2;
19566   if (!arg2) {
19567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19568     return 0;
19569   }
19570   {
19571     try {
19572       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19573     } catch (std::out_of_range& e) {
19574       {
19575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19576       };
19577     } catch (std::exception& e) {
19578       {
19579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19580       };
19581     } catch (Dali::DaliException e) {
19582       {
19583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19584       };
19585     } catch (...) {
19586       {
19587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19588       };
19589     }
19590   }
19591
19592   jresult = (void *)result;
19593   return jresult;
19594 }
19595
19596
19597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19598   unsigned long jresult ;
19599   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19600   std::size_t result;
19601
19602   arg1 = (Dali::PropertyCondition *)jarg1;
19603   {
19604     try {
19605       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19606     } catch (std::out_of_range& e) {
19607       {
19608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19609       };
19610     } catch (std::exception& e) {
19611       {
19612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19613       };
19614     } catch (...) {
19615       {
19616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19617       };
19618     }
19619   }
19620   jresult = (unsigned long)result;
19621   return jresult;
19622 }
19623
19624
19625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19626   float jresult ;
19627   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19628   std::size_t arg2 ;
19629   float result;
19630
19631   arg1 = (Dali::PropertyCondition *)jarg1;
19632   arg2 = (std::size_t)jarg2;
19633   {
19634     try {
19635       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19636     } catch (std::out_of_range& e) {
19637       {
19638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19639       };
19640     } catch (std::exception& e) {
19641       {
19642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19643       };
19644     } catch (...) {
19645       {
19646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19647       };
19648     }
19649   }
19650   jresult = result;
19651   return jresult;
19652 }
19653
19654
19655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19656   void * jresult ;
19657   float arg1 ;
19658   Dali::PropertyCondition result;
19659
19660   arg1 = (float)jarg1;
19661   {
19662     try {
19663       result = Dali::LessThanCondition(arg1);
19664     } catch (std::out_of_range& e) {
19665       {
19666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (std::exception& e) {
19669       {
19670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19671       };
19672     } catch (Dali::DaliException e) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19675       };
19676     } catch (...) {
19677       {
19678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19679       };
19680     }
19681   }
19682
19683   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19684   return jresult;
19685 }
19686
19687
19688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19689   void * jresult ;
19690   float arg1 ;
19691   Dali::PropertyCondition result;
19692
19693   arg1 = (float)jarg1;
19694   {
19695     try {
19696       result = Dali::GreaterThanCondition(arg1);
19697     } catch (std::out_of_range& e) {
19698       {
19699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (std::exception& e) {
19702       {
19703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19704       };
19705     } catch (Dali::DaliException e) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19708       };
19709     } catch (...) {
19710       {
19711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19712       };
19713     }
19714   }
19715
19716   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19717   return jresult;
19718 }
19719
19720
19721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19722   void * jresult ;
19723   float arg1 ;
19724   float arg2 ;
19725   Dali::PropertyCondition result;
19726
19727   arg1 = (float)jarg1;
19728   arg2 = (float)jarg2;
19729   {
19730     try {
19731       result = Dali::InsideCondition(arg1,arg2);
19732     } catch (std::out_of_range& e) {
19733       {
19734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (std::exception& e) {
19737       {
19738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19739       };
19740     } catch (Dali::DaliException e) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19743       };
19744     } catch (...) {
19745       {
19746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19747       };
19748     }
19749   }
19750
19751   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19752   return jresult;
19753 }
19754
19755
19756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19757   void * jresult ;
19758   float arg1 ;
19759   float arg2 ;
19760   Dali::PropertyCondition result;
19761
19762   arg1 = (float)jarg1;
19763   arg2 = (float)jarg2;
19764   {
19765     try {
19766       result = Dali::OutsideCondition(arg1,arg2);
19767     } catch (std::out_of_range& e) {
19768       {
19769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (std::exception& e) {
19772       {
19773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19774       };
19775     } catch (Dali::DaliException e) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19778       };
19779     } catch (...) {
19780       {
19781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19782       };
19783     }
19784   }
19785
19786   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19787   return jresult;
19788 }
19789
19790
19791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19792   void * jresult ;
19793   float arg1 ;
19794   float arg2 ;
19795   Dali::PropertyCondition result;
19796
19797   arg1 = (float)jarg1;
19798   arg2 = (float)jarg2;
19799   {
19800     try {
19801       result = Dali::StepCondition(arg1,arg2);
19802     } catch (std::out_of_range& e) {
19803       {
19804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (std::exception& e) {
19807       {
19808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19809       };
19810     } catch (Dali::DaliException e) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19813       };
19814     } catch (...) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19817       };
19818     }
19819   }
19820
19821   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19822   return jresult;
19823 }
19824
19825
19826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19827   void * jresult ;
19828   float arg1 ;
19829   Dali::PropertyCondition result;
19830
19831   arg1 = (float)jarg1;
19832   {
19833     try {
19834       result = Dali::StepCondition(arg1);
19835     } catch (std::out_of_range& e) {
19836       {
19837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (std::exception& e) {
19840       {
19841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19842       };
19843     } catch (Dali::DaliException e) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19846       };
19847     } catch (...) {
19848       {
19849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19850       };
19851     }
19852   }
19853
19854   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19855   return jresult;
19856 }
19857
19858
19859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19860   void * jresult ;
19861   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19862   Dali::PropertyCondition result;
19863
19864   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19865   if (!arg1) {
19866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19867     return 0;
19868   }
19869   {
19870     try {
19871       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19872     } catch (std::out_of_range& e) {
19873       {
19874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (std::exception& e) {
19877       {
19878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19879       };
19880     } catch (Dali::DaliException e) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19883       };
19884     } catch (...) {
19885       {
19886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19887       };
19888     }
19889   }
19890
19891   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19892   return jresult;
19893 }
19894
19895
19896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19897   void * jresult ;
19898   Dali::PropertyNotification *result = 0 ;
19899
19900   {
19901     try {
19902       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19903     } catch (std::out_of_range& e) {
19904       {
19905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19906       };
19907     } catch (std::exception& e) {
19908       {
19909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19910       };
19911     } catch (Dali::DaliException e) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19914       };
19915     } catch (...) {
19916       {
19917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19918       };
19919     }
19920   }
19921
19922   jresult = (void *)result;
19923   return jresult;
19924 }
19925
19926
19927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19928   void * jresult ;
19929   Dali::BaseHandle arg1 ;
19930   Dali::BaseHandle *argp1 ;
19931   Dali::PropertyNotification result;
19932
19933   argp1 = (Dali::BaseHandle *)jarg1;
19934   if (!argp1) {
19935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19936     return 0;
19937   }
19938   arg1 = *argp1;
19939   {
19940     try {
19941       result = Dali::PropertyNotification::DownCast(arg1);
19942     } catch (std::out_of_range& e) {
19943       {
19944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19945       };
19946     } catch (std::exception& e) {
19947       {
19948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19949       };
19950     } catch (Dali::DaliException e) {
19951       {
19952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19953       };
19954     } catch (...) {
19955       {
19956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19957       };
19958     }
19959   }
19960
19961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19962   return jresult;
19963 }
19964
19965
19966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19967   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19968
19969   arg1 = (Dali::PropertyNotification *)jarg1;
19970   {
19971     try {
19972       delete arg1;
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19988       };
19989     }
19990   }
19991
19992 }
19993
19994
19995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19996   void * jresult ;
19997   Dali::PropertyNotification *arg1 = 0 ;
19998   Dali::PropertyNotification *result = 0 ;
19999
20000   arg1 = (Dali::PropertyNotification *)jarg1;
20001   if (!arg1) {
20002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20003     return 0;
20004   }
20005   {
20006     try {
20007       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (Dali::DaliException e) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20019       };
20020     } catch (...) {
20021       {
20022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20023       };
20024     }
20025   }
20026
20027   jresult = (void *)result;
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::PropertyNotification *arg2 = 0 ;
20036   Dali::PropertyNotification *result = 0 ;
20037
20038   arg1 = (Dali::PropertyNotification *)jarg1;
20039   arg2 = (Dali::PropertyNotification *)jarg2;
20040   if (!arg2) {
20041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20042     return 0;
20043   }
20044   {
20045     try {
20046       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20047     } catch (std::out_of_range& e) {
20048       {
20049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20050       };
20051     } catch (std::exception& e) {
20052       {
20053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20054       };
20055     } catch (Dali::DaliException e) {
20056       {
20057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20058       };
20059     } catch (...) {
20060       {
20061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20062       };
20063     }
20064   }
20065
20066   jresult = (void *)result;
20067   return jresult;
20068 }
20069
20070
20071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20072   void * jresult ;
20073   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20074   Dali::PropertyCondition result;
20075
20076   arg1 = (Dali::PropertyNotification *)jarg1;
20077   {
20078     try {
20079       result = (arg1)->GetCondition();
20080     } catch (std::out_of_range& e) {
20081       {
20082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20083       };
20084     } catch (std::exception& e) {
20085       {
20086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20087       };
20088     } catch (Dali::DaliException e) {
20089       {
20090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20091       };
20092     } catch (...) {
20093       {
20094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20095       };
20096     }
20097   }
20098
20099   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20100   return jresult;
20101 }
20102
20103
20104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20105   void * jresult ;
20106   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20107   Dali::Handle result;
20108
20109   arg1 = (Dali::PropertyNotification *)jarg1;
20110   {
20111     try {
20112       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20113     } catch (std::out_of_range& e) {
20114       {
20115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20116       };
20117     } catch (std::exception& e) {
20118       {
20119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20120       };
20121     } catch (Dali::DaliException e) {
20122       {
20123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20124       };
20125     } catch (...) {
20126       {
20127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20128       };
20129     }
20130   }
20131
20132   jresult = new Dali::Handle((const Dali::Handle &)result);
20133   return jresult;
20134 }
20135
20136
20137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20138   int jresult ;
20139   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20140   Dali::Property::Index result;
20141
20142   arg1 = (Dali::PropertyNotification *)jarg1;
20143   {
20144     try {
20145       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20146     } catch (std::out_of_range& e) {
20147       {
20148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20149       };
20150     } catch (std::exception& e) {
20151       {
20152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20153       };
20154     } catch (Dali::DaliException e) {
20155       {
20156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20157       };
20158     } catch (...) {
20159       {
20160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20161       };
20162     }
20163   }
20164
20165   jresult = result;
20166   return jresult;
20167 }
20168
20169
20170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20171   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20172   Dali::PropertyNotification::NotifyMode arg2 ;
20173
20174   arg1 = (Dali::PropertyNotification *)jarg1;
20175   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20176   {
20177     try {
20178       (arg1)->SetNotifyMode(arg2);
20179     } catch (std::out_of_range& e) {
20180       {
20181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20182       };
20183     } catch (std::exception& e) {
20184       {
20185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20186       };
20187     } catch (Dali::DaliException e) {
20188       {
20189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20190       };
20191     } catch (...) {
20192       {
20193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20194       };
20195     }
20196   }
20197
20198 }
20199
20200
20201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20202   int jresult ;
20203   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20204   Dali::PropertyNotification::NotifyMode result;
20205
20206   arg1 = (Dali::PropertyNotification *)jarg1;
20207   {
20208     try {
20209       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20210     } catch (std::out_of_range& e) {
20211       {
20212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20213       };
20214     } catch (std::exception& e) {
20215       {
20216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20217       };
20218     } catch (Dali::DaliException e) {
20219       {
20220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20221       };
20222     } catch (...) {
20223       {
20224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20225       };
20226     }
20227   }
20228
20229   jresult = (int)result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20235   unsigned int jresult ;
20236   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20237   bool result;
20238
20239   arg1 = (Dali::PropertyNotification *)jarg1;
20240   {
20241     try {
20242       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20243     } catch (std::out_of_range& e) {
20244       {
20245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20246       };
20247     } catch (std::exception& e) {
20248       {
20249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20250       };
20251     } catch (Dali::DaliException e) {
20252       {
20253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20254       };
20255     } catch (...) {
20256       {
20257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20258       };
20259     }
20260   }
20261
20262   jresult = result;
20263   return jresult;
20264 }
20265
20266
20267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20268   void * jresult ;
20269   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20270   Dali::PropertyNotifySignalType *result = 0 ;
20271
20272   arg1 = (Dali::PropertyNotification *)jarg1;
20273   {
20274     try {
20275       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20276     } catch (std::out_of_range& e) {
20277       {
20278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20279       };
20280     } catch (std::exception& e) {
20281       {
20282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20283       };
20284     } catch (Dali::DaliException e) {
20285       {
20286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20287       };
20288     } catch (...) {
20289       {
20290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20291       };
20292     }
20293   }
20294
20295   jresult = (void *)result;
20296   return jresult;
20297 }
20298
20299
20300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20301   void * jresult ;
20302   Dali::Handle *result = 0 ;
20303
20304   {
20305     try {
20306       result = (Dali::Handle *)new Dali::Handle();
20307     } catch (std::out_of_range& e) {
20308       {
20309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20310       };
20311     } catch (std::exception& e) {
20312       {
20313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20314       };
20315     } catch (Dali::DaliException e) {
20316       {
20317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20318       };
20319     } catch (...) {
20320       {
20321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20322       };
20323     }
20324   }
20325
20326   jresult = (void *)result;
20327   return jresult;
20328 }
20329
20330
20331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20332   void * jresult ;
20333   Dali::Handle result;
20334
20335   {
20336     try {
20337       result = Dali::Handle::New();
20338     } catch (std::out_of_range& e) {
20339       {
20340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20341       };
20342     } catch (std::exception& e) {
20343       {
20344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20345       };
20346     } catch (Dali::DaliException e) {
20347       {
20348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20349       };
20350     } catch (...) {
20351       {
20352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20353       };
20354     }
20355   }
20356
20357   jresult = new Dali::Handle((const Dali::Handle &)result);
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20363   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20364
20365   arg1 = (Dali::Handle *)jarg1;
20366   {
20367     try {
20368       delete arg1;
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20384       };
20385     }
20386   }
20387
20388 }
20389
20390
20391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20392   void * jresult ;
20393   Dali::Handle *arg1 = 0 ;
20394   Dali::Handle *result = 0 ;
20395
20396   arg1 = (Dali::Handle *)jarg1;
20397   if (!arg1) {
20398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20399     return 0;
20400   }
20401   {
20402     try {
20403       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20404     } catch (std::out_of_range& e) {
20405       {
20406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20407       };
20408     } catch (std::exception& e) {
20409       {
20410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (Dali::DaliException e) {
20413       {
20414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20415       };
20416     } catch (...) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20419       };
20420     }
20421   }
20422
20423   jresult = (void *)result;
20424   return jresult;
20425 }
20426
20427
20428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20429   void * jresult ;
20430   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20431   Dali::Handle *arg2 = 0 ;
20432   Dali::Handle *result = 0 ;
20433
20434   arg1 = (Dali::Handle *)jarg1;
20435   arg2 = (Dali::Handle *)jarg2;
20436   if (!arg2) {
20437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20438     return 0;
20439   }
20440   {
20441     try {
20442       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = (void *)result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20468   void * jresult ;
20469   Dali::BaseHandle arg1 ;
20470   Dali::BaseHandle *argp1 ;
20471   Dali::Handle result;
20472
20473   argp1 = (Dali::BaseHandle *)jarg1;
20474   if (!argp1) {
20475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20476     return 0;
20477   }
20478   arg1 = *argp1;
20479   {
20480     try {
20481       result = Dali::Handle::DownCast(arg1);
20482     } catch (std::out_of_range& e) {
20483       {
20484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (std::exception& e) {
20487       {
20488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20489       };
20490     } catch (Dali::DaliException e) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20493       };
20494     } catch (...) {
20495       {
20496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20497       };
20498     }
20499   }
20500
20501   jresult = new Dali::Handle((const Dali::Handle &)result);
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20507   unsigned int jresult ;
20508   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20509   Dali::Handle::Capability arg2 ;
20510   bool result;
20511
20512   arg1 = (Dali::Handle *)jarg1;
20513   arg2 = (Dali::Handle::Capability)jarg2;
20514   {
20515     try {
20516       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20517     } catch (std::out_of_range& e) {
20518       {
20519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (std::exception& e) {
20522       {
20523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20524       };
20525     } catch (Dali::DaliException e) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20528       };
20529     } catch (...) {
20530       {
20531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20532       };
20533     }
20534   }
20535
20536   jresult = result;
20537   return jresult;
20538 }
20539
20540
20541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20542   unsigned int jresult ;
20543   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20544   unsigned int result;
20545
20546   arg1 = (Dali::Handle *)jarg1;
20547   {
20548     try {
20549       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20550     } catch (std::out_of_range& e) {
20551       {
20552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20553       };
20554     } catch (std::exception& e) {
20555       {
20556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20557       };
20558     } catch (Dali::DaliException e) {
20559       {
20560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20561       };
20562     } catch (...) {
20563       {
20564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20565       };
20566     }
20567   }
20568
20569   jresult = result;
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20575   char * jresult ;
20576   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20577   Dali::Property::Index arg2 ;
20578   std::string result;
20579
20580   arg1 = (Dali::Handle *)jarg1;
20581   arg2 = (Dali::Property::Index)jarg2;
20582   {
20583     try {
20584       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20585     } catch (std::out_of_range& e) {
20586       {
20587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20588       };
20589     } catch (std::exception& e) {
20590       {
20591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (Dali::DaliException e) {
20594       {
20595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20596       };
20597     } catch (...) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20600       };
20601     }
20602   }
20603
20604   jresult = SWIG_csharp_string_callback((&result)->c_str());
20605   return jresult;
20606 }
20607
20608
20609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20610   int jresult ;
20611   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20612   std::string *arg2 = 0 ;
20613   Dali::Property::Index result;
20614
20615   arg1 = (Dali::Handle *)jarg1;
20616   if (!jarg2) {
20617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20618     return 0;
20619   }
20620   std::string arg2_str(jarg2);
20621   arg2 = &arg2_str;
20622   {
20623     try {
20624       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20625     } catch (std::out_of_range& e) {
20626       {
20627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20628       };
20629     } catch (std::exception& e) {
20630       {
20631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20632       };
20633     } catch (Dali::DaliException e) {
20634       {
20635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20636       };
20637     } catch (...) {
20638       {
20639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20640       };
20641     }
20642   }
20643
20644   jresult = result;
20645
20646   //argout typemap for const std::string&
20647
20648   return jresult;
20649 }
20650
20651
20652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20653   unsigned int jresult ;
20654   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20655   Dali::Property::Index arg2 ;
20656   bool result;
20657
20658   arg1 = (Dali::Handle *)jarg1;
20659   arg2 = (Dali::Property::Index)jarg2;
20660   {
20661     try {
20662       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20663     } catch (std::out_of_range& e) {
20664       {
20665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (std::exception& e) {
20668       {
20669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20670       };
20671     } catch (Dali::DaliException e) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20674       };
20675     } catch (...) {
20676       {
20677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20678       };
20679     }
20680   }
20681
20682   jresult = result;
20683   return jresult;
20684 }
20685
20686
20687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20688   unsigned int jresult ;
20689   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20690   Dali::Property::Index arg2 ;
20691   bool result;
20692
20693   arg1 = (Dali::Handle *)jarg1;
20694   arg2 = (Dali::Property::Index)jarg2;
20695   {
20696     try {
20697       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20698     } catch (std::out_of_range& e) {
20699       {
20700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (std::exception& e) {
20703       {
20704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (Dali::DaliException e) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20709       };
20710     } catch (...) {
20711       {
20712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20713       };
20714     }
20715   }
20716
20717   jresult = result;
20718   return jresult;
20719 }
20720
20721
20722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20723   unsigned int jresult ;
20724   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20725   Dali::Property::Index arg2 ;
20726   bool result;
20727
20728   arg1 = (Dali::Handle *)jarg1;
20729   arg2 = (Dali::Property::Index)jarg2;
20730   {
20731     try {
20732       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20748       };
20749     }
20750   }
20751
20752   jresult = result;
20753   return jresult;
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   Dali::Property::Index arg2 ;
20761   Dali::Property::Type result;
20762
20763   arg1 = (Dali::Handle *)jarg1;
20764   arg2 = (Dali::Property::Index)jarg2;
20765   {
20766     try {
20767       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20768     } catch (std::out_of_range& e) {
20769       {
20770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20771       };
20772     } catch (std::exception& e) {
20773       {
20774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20775       };
20776     } catch (Dali::DaliException e) {
20777       {
20778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20779       };
20780     } catch (...) {
20781       {
20782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20783       };
20784     }
20785   }
20786
20787   jresult = (int)result;
20788   return jresult;
20789 }
20790
20791
20792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20793   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20794   Dali::Property::Index arg2 ;
20795   Dali::Property::Value *arg3 = 0 ;
20796
20797   arg1 = (Dali::Handle *)jarg1;
20798   arg2 = (Dali::Property::Index)jarg2;
20799   arg3 = (Dali::Property::Value *)jarg3;
20800   if (!arg3) {
20801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20802     return ;
20803   }
20804   {
20805     try {
20806       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20807     } catch (std::out_of_range& e) {
20808       {
20809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20810       };
20811     } catch (std::exception& e) {
20812       {
20813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20814       };
20815     } catch (Dali::DaliException e) {
20816       {
20817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20818       };
20819     } catch (...) {
20820       {
20821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20822       };
20823     }
20824   }
20825
20826 }
20827
20828
20829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20830   int jresult ;
20831   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20832   std::string *arg2 = 0 ;
20833   Dali::Property::Value *arg3 = 0 ;
20834   Dali::Property::Index result;
20835
20836   arg1 = (Dali::Handle *)jarg1;
20837   if (!jarg2) {
20838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20839     return 0;
20840   }
20841   std::string arg2_str(jarg2);
20842   arg2 = &arg2_str;
20843   arg3 = (Dali::Property::Value *)jarg3;
20844   if (!arg3) {
20845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20846     return 0;
20847   }
20848   {
20849     try {
20850       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20851     } catch (std::out_of_range& e) {
20852       {
20853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (std::exception& e) {
20856       {
20857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (Dali::DaliException e) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20862       };
20863     } catch (...) {
20864       {
20865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20866       };
20867     }
20868   }
20869
20870   jresult = result;
20871
20872   //argout typemap for const std::string&
20873
20874   return jresult;
20875 }
20876
20877
20878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20879   int jresult ;
20880   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20881   std::string *arg2 = 0 ;
20882   Dali::Property::Value *arg3 = 0 ;
20883   Dali::Property::AccessMode arg4 ;
20884   Dali::Property::Index result;
20885
20886   arg1 = (Dali::Handle *)jarg1;
20887   if (!jarg2) {
20888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20889     return 0;
20890   }
20891   std::string arg2_str(jarg2);
20892   arg2 = &arg2_str;
20893   arg3 = (Dali::Property::Value *)jarg3;
20894   if (!arg3) {
20895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20896     return 0;
20897   }
20898   arg4 = (Dali::Property::AccessMode)jarg4;
20899   {
20900     try {
20901       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20902     } catch (std::out_of_range& e) {
20903       {
20904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20905       };
20906     } catch (std::exception& e) {
20907       {
20908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20909       };
20910     } catch (Dali::DaliException e) {
20911       {
20912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20913       };
20914     } catch (...) {
20915       {
20916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20917       };
20918     }
20919   }
20920
20921   jresult = result;
20922
20923   //argout typemap for const std::string&
20924
20925   return jresult;
20926 }
20927
20928
20929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20930   void * jresult ;
20931   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20932   Dali::Property::Index arg2 ;
20933   Dali::Property::Value result;
20934
20935   arg1 = (Dali::Handle *)jarg1;
20936   arg2 = (Dali::Property::Index)jarg2;
20937   {
20938     try {
20939       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20940     } catch (std::out_of_range& e) {
20941       {
20942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (std::exception& e) {
20945       {
20946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (Dali::DaliException e) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20951       };
20952     } catch (...) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20955       };
20956     }
20957   }
20958
20959   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20965   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20966   Dali::Property::IndexContainer *arg2 = 0 ;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::IndexContainer *)jarg2;
20970   if (!arg2) {
20971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20972     return ;
20973   }
20974   {
20975     try {
20976       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20977     } catch (std::out_of_range& e) {
20978       {
20979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20980       };
20981     } catch (std::exception& e) {
20982       {
20983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20984       };
20985     } catch (Dali::DaliException e) {
20986       {
20987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20988       };
20989     } catch (...) {
20990       {
20991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20992       };
20993     }
20994   }
20995
20996 }
20997
20998
20999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
21000   void * jresult ;
21001   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21002   Dali::Property::Index arg2 ;
21003   Dali::PropertyCondition *arg3 = 0 ;
21004   Dali::PropertyNotification result;
21005
21006   arg1 = (Dali::Handle *)jarg1;
21007   arg2 = (Dali::Property::Index)jarg2;
21008   arg3 = (Dali::PropertyCondition *)jarg3;
21009   if (!arg3) {
21010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21011     return 0;
21012   }
21013   {
21014     try {
21015       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
21016     } catch (std::out_of_range& e) {
21017       {
21018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21019       };
21020     } catch (std::exception& e) {
21021       {
21022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21023       };
21024     } catch (Dali::DaliException e) {
21025       {
21026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21027       };
21028     } catch (...) {
21029       {
21030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21031       };
21032     }
21033   }
21034
21035   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21036   return jresult;
21037 }
21038
21039
21040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21041   void * jresult ;
21042   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21043   Dali::Property::Index arg2 ;
21044   int arg3 ;
21045   Dali::PropertyCondition *arg4 = 0 ;
21046   Dali::PropertyNotification result;
21047
21048   arg1 = (Dali::Handle *)jarg1;
21049   arg2 = (Dali::Property::Index)jarg2;
21050   arg3 = (int)jarg3;
21051   arg4 = (Dali::PropertyCondition *)jarg4;
21052   if (!arg4) {
21053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21054     return 0;
21055   }
21056   {
21057     try {
21058       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21059     } catch (std::out_of_range& e) {
21060       {
21061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (std::exception& e) {
21064       {
21065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21066       };
21067     } catch (Dali::DaliException e) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21070       };
21071     } catch (...) {
21072       {
21073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21074       };
21075     }
21076   }
21077
21078   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21079   return jresult;
21080 }
21081
21082
21083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21084   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21085   Dali::PropertyNotification arg2 ;
21086   Dali::PropertyNotification *argp2 ;
21087
21088   arg1 = (Dali::Handle *)jarg1;
21089   argp2 = (Dali::PropertyNotification *)jarg2;
21090   if (!argp2) {
21091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21092     return ;
21093   }
21094   arg2 = *argp2;
21095   {
21096     try {
21097       (arg1)->RemovePropertyNotification(arg2);
21098     } catch (std::out_of_range& e) {
21099       {
21100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21101       };
21102     } catch (std::exception& e) {
21103       {
21104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (Dali::DaliException e) {
21107       {
21108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21109       };
21110     } catch (...) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21113       };
21114     }
21115   }
21116
21117 }
21118
21119
21120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21121   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21122
21123   arg1 = (Dali::Handle *)jarg1;
21124   {
21125     try {
21126       (arg1)->RemovePropertyNotifications();
21127     } catch (std::out_of_range& e) {
21128       {
21129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21130       };
21131     } catch (std::exception& e) {
21132       {
21133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21134       };
21135     } catch (Dali::DaliException e) {
21136       {
21137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21138       };
21139     } catch (...) {
21140       {
21141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21142       };
21143     }
21144   }
21145
21146 }
21147
21148
21149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21151
21152   arg1 = (Dali::Handle *)jarg1;
21153   {
21154     try {
21155       (arg1)->RemoveConstraints();
21156     } catch (std::out_of_range& e) {
21157       {
21158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21159       };
21160     } catch (std::exception& e) {
21161       {
21162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21163       };
21164     } catch (Dali::DaliException e) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21167       };
21168     } catch (...) {
21169       {
21170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21171       };
21172     }
21173   }
21174
21175 }
21176
21177
21178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21179   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21180   unsigned int arg2 ;
21181
21182   arg1 = (Dali::Handle *)jarg1;
21183   arg2 = (unsigned int)jarg2;
21184   {
21185     try {
21186       (arg1)->RemoveConstraints(arg2);
21187     } catch (std::out_of_range& e) {
21188       {
21189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21190       };
21191     } catch (std::exception& e) {
21192       {
21193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21194       };
21195     } catch (Dali::DaliException e) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21198       };
21199     } catch (...) {
21200       {
21201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21202       };
21203     }
21204   }
21205
21206 }
21207
21208
21209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21210   int jresult ;
21211   Dali::Property::Index result;
21212
21213   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21214   jresult = result;
21215   return jresult;
21216 }
21217
21218
21219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21220   void * jresult ;
21221   Dali::Handle result;
21222
21223   {
21224     try {
21225       result = Dali::WeightObject::New();
21226     } catch (std::out_of_range& e) {
21227       {
21228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21229       };
21230     } catch (std::exception& e) {
21231       {
21232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21233       };
21234     } catch (Dali::DaliException e) {
21235       {
21236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21237       };
21238     } catch (...) {
21239       {
21240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21241       };
21242     }
21243   }
21244
21245   jresult = new Dali::Handle((const Dali::Handle &)result);
21246   return jresult;
21247 }
21248
21249
21250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21251   void * jresult ;
21252   Dali::TypeInfo *result = 0 ;
21253
21254   {
21255     try {
21256       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21257     } catch (std::out_of_range& e) {
21258       {
21259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21260       };
21261     } catch (std::exception& e) {
21262       {
21263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21264       };
21265     } catch (Dali::DaliException e) {
21266       {
21267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21268       };
21269     } catch (...) {
21270       {
21271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21272       };
21273     }
21274   }
21275
21276   jresult = (void *)result;
21277   return jresult;
21278 }
21279
21280
21281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21282   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21283
21284   arg1 = (Dali::TypeInfo *)jarg1;
21285   {
21286     try {
21287       delete arg1;
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21303       };
21304     }
21305   }
21306
21307 }
21308
21309
21310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21311   void * jresult ;
21312   Dali::TypeInfo *arg1 = 0 ;
21313   Dali::TypeInfo *result = 0 ;
21314
21315   arg1 = (Dali::TypeInfo *)jarg1;
21316   if (!arg1) {
21317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21318     return 0;
21319   }
21320   {
21321     try {
21322       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21323     } catch (std::out_of_range& e) {
21324       {
21325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (std::exception& e) {
21328       {
21329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (Dali::DaliException e) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341
21342   jresult = (void *)result;
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21348   void * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   Dali::TypeInfo *arg2 = 0 ;
21351   Dali::TypeInfo *result = 0 ;
21352
21353   arg1 = (Dali::TypeInfo *)jarg1;
21354   arg2 = (Dali::TypeInfo *)jarg2;
21355   if (!arg2) {
21356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21357     return 0;
21358   }
21359   {
21360     try {
21361       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21362     } catch (std::out_of_range& e) {
21363       {
21364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21365       };
21366     } catch (std::exception& e) {
21367       {
21368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21369       };
21370     } catch (Dali::DaliException e) {
21371       {
21372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21373       };
21374     } catch (...) {
21375       {
21376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21377       };
21378     }
21379   }
21380
21381   jresult = (void *)result;
21382   return jresult;
21383 }
21384
21385
21386 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21387   char * jresult ;
21388   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21389   std::string *result = 0 ;
21390
21391   arg1 = (Dali::TypeInfo *)jarg1;
21392   {
21393     try {
21394       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21395     } catch (std::out_of_range& e) {
21396       {
21397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21398       };
21399     } catch (std::exception& e) {
21400       {
21401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21402       };
21403     } catch (Dali::DaliException e) {
21404       {
21405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21406       };
21407     } catch (...) {
21408       {
21409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21410       };
21411     }
21412   }
21413
21414   jresult = SWIG_csharp_string_callback(result->c_str());
21415   return jresult;
21416 }
21417
21418
21419 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21420   char * jresult ;
21421   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21422   std::string *result = 0 ;
21423
21424   arg1 = (Dali::TypeInfo *)jarg1;
21425   {
21426     try {
21427       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21428     } catch (std::out_of_range& e) {
21429       {
21430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21431       };
21432     } catch (std::exception& e) {
21433       {
21434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21435       };
21436     } catch (Dali::DaliException e) {
21437       {
21438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21439       };
21440     } catch (...) {
21441       {
21442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21443       };
21444     }
21445   }
21446
21447   jresult = SWIG_csharp_string_callback(result->c_str());
21448   return jresult;
21449 }
21450
21451
21452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21453   void * jresult ;
21454   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21455   Dali::BaseHandle result;
21456
21457   arg1 = (Dali::TypeInfo *)jarg1;
21458   {
21459     try {
21460       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21461     } catch (std::out_of_range& e) {
21462       {
21463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (std::exception& e) {
21466       {
21467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (Dali::DaliException e) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21472       };
21473     } catch (...) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21476       };
21477     }
21478   }
21479
21480   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21481   return jresult;
21482 }
21483
21484
21485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21486   unsigned long jresult ;
21487   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21488   size_t result;
21489
21490   arg1 = (Dali::TypeInfo *)jarg1;
21491   {
21492     try {
21493       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21494     } catch (std::out_of_range& e) {
21495       {
21496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (std::exception& e) {
21499       {
21500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21501       };
21502     } catch (Dali::DaliException e) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21505       };
21506     } catch (...) {
21507       {
21508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21509       };
21510     }
21511   }
21512
21513   jresult = (unsigned long)result;
21514   return jresult;
21515 }
21516
21517
21518 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21519   char * jresult ;
21520   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21521   size_t arg2 ;
21522   std::string result;
21523
21524   arg1 = (Dali::TypeInfo *)jarg1;
21525   arg2 = (size_t)jarg2;
21526   {
21527     try {
21528       result = (arg1)->GetActionName(arg2);
21529     } catch (std::out_of_range& e) {
21530       {
21531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (std::exception& e) {
21534       {
21535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21536       };
21537     } catch (Dali::DaliException e) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21540       };
21541     } catch (...) {
21542       {
21543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21544       };
21545     }
21546   }
21547
21548   jresult = SWIG_csharp_string_callback((&result)->c_str());
21549   return jresult;
21550 }
21551
21552
21553 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21554   unsigned long jresult ;
21555   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21556   size_t result;
21557
21558   arg1 = (Dali::TypeInfo *)jarg1;
21559   {
21560     try {
21561       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21562     } catch (std::out_of_range& e) {
21563       {
21564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (std::exception& e) {
21567       {
21568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21569       };
21570     } catch (Dali::DaliException e) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21573       };
21574     } catch (...) {
21575       {
21576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21577       };
21578     }
21579   }
21580
21581   jresult = (unsigned long)result;
21582   return jresult;
21583 }
21584
21585
21586 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21587   char * jresult ;
21588   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21589   size_t arg2 ;
21590   std::string result;
21591
21592   arg1 = (Dali::TypeInfo *)jarg1;
21593   arg2 = (size_t)jarg2;
21594   {
21595     try {
21596       result = (arg1)->GetSignalName(arg2);
21597     } catch (std::out_of_range& e) {
21598       {
21599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21600       };
21601     } catch (std::exception& e) {
21602       {
21603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (Dali::DaliException e) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21608       };
21609     } catch (...) {
21610       {
21611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21612       };
21613     }
21614   }
21615
21616   jresult = SWIG_csharp_string_callback((&result)->c_str());
21617   return jresult;
21618 }
21619
21620
21621 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21622   unsigned long jresult ;
21623   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21624   size_t result;
21625
21626   arg1 = (Dali::TypeInfo *)jarg1;
21627   {
21628     try {
21629       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21630     } catch (std::out_of_range& e) {
21631       {
21632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (std::exception& e) {
21635       {
21636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21637       };
21638     } catch (Dali::DaliException e) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21641       };
21642     } catch (...) {
21643       {
21644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21645       };
21646     }
21647   }
21648
21649   jresult = (unsigned long)result;
21650   return jresult;
21651 }
21652
21653
21654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21655   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21656   Dali::Property::IndexContainer *arg2 = 0 ;
21657
21658   arg1 = (Dali::TypeInfo *)jarg1;
21659   arg2 = (Dali::Property::IndexContainer *)jarg2;
21660   if (!arg2) {
21661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21662     return ;
21663   }
21664   {
21665     try {
21666       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21667     } catch (std::out_of_range& e) {
21668       {
21669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21670       };
21671     } catch (std::exception& e) {
21672       {
21673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21674       };
21675     } catch (Dali::DaliException e) {
21676       {
21677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21678       };
21679     } catch (...) {
21680       {
21681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21682       };
21683     }
21684   }
21685
21686 }
21687
21688
21689 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21690   char * jresult ;
21691   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21692   Dali::Property::Index arg2 ;
21693   std::string *result = 0 ;
21694
21695   arg1 = (Dali::TypeInfo *)jarg1;
21696   arg2 = (Dali::Property::Index)jarg2;
21697   {
21698     try {
21699       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21700     } catch (std::out_of_range& e) {
21701       {
21702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21703       };
21704     } catch (std::exception& e) {
21705       {
21706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21707       };
21708     } catch (Dali::DaliException e) {
21709       {
21710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21711       };
21712     } catch (...) {
21713       {
21714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21715       };
21716     }
21717   }
21718
21719   jresult = SWIG_csharp_string_callback(result->c_str());
21720   return jresult;
21721 }
21722
21723
21724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21725   void * jresult ;
21726   Dali::TypeRegistry result;
21727
21728   {
21729     try {
21730       result = Dali::TypeRegistry::Get();
21731     } catch (std::out_of_range& e) {
21732       {
21733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21734       };
21735     } catch (std::exception& e) {
21736       {
21737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21738       };
21739     } catch (Dali::DaliException e) {
21740       {
21741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21742       };
21743     } catch (...) {
21744       {
21745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21746       };
21747     }
21748   }
21749
21750   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21751   return jresult;
21752 }
21753
21754
21755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21756   void * jresult ;
21757   Dali::TypeRegistry *result = 0 ;
21758
21759   {
21760     try {
21761       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21762     } catch (std::out_of_range& e) {
21763       {
21764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21765       };
21766     } catch (std::exception& e) {
21767       {
21768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21769       };
21770     } catch (Dali::DaliException e) {
21771       {
21772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21773       };
21774     } catch (...) {
21775       {
21776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21777       };
21778     }
21779   }
21780
21781   jresult = (void *)result;
21782   return jresult;
21783 }
21784
21785
21786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21787   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21788
21789   arg1 = (Dali::TypeRegistry *)jarg1;
21790   {
21791     try {
21792       delete arg1;
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21808       };
21809     }
21810   }
21811
21812 }
21813
21814
21815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21816   void * jresult ;
21817   Dali::TypeRegistry *arg1 = 0 ;
21818   Dali::TypeRegistry *result = 0 ;
21819
21820   arg1 = (Dali::TypeRegistry *)jarg1;
21821   if (!arg1) {
21822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21823     return 0;
21824   }
21825   {
21826     try {
21827       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21828     } catch (std::out_of_range& e) {
21829       {
21830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21831       };
21832     } catch (std::exception& e) {
21833       {
21834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21835       };
21836     } catch (Dali::DaliException e) {
21837       {
21838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21839       };
21840     } catch (...) {
21841       {
21842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21843       };
21844     }
21845   }
21846
21847   jresult = (void *)result;
21848   return jresult;
21849 }
21850
21851
21852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21853   void * jresult ;
21854   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21855   Dali::TypeRegistry *arg2 = 0 ;
21856   Dali::TypeRegistry *result = 0 ;
21857
21858   arg1 = (Dali::TypeRegistry *)jarg1;
21859   arg2 = (Dali::TypeRegistry *)jarg2;
21860   if (!arg2) {
21861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21862     return 0;
21863   }
21864   {
21865     try {
21866       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21867     } catch (std::out_of_range& e) {
21868       {
21869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21870       };
21871     } catch (std::exception& e) {
21872       {
21873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21874       };
21875     } catch (Dali::DaliException e) {
21876       {
21877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21878       };
21879     } catch (...) {
21880       {
21881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21882       };
21883     }
21884   }
21885
21886   jresult = (void *)result;
21887   return jresult;
21888 }
21889
21890
21891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21892   void * jresult ;
21893   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21894   std::string *arg2 = 0 ;
21895   Dali::TypeInfo result;
21896
21897   arg1 = (Dali::TypeRegistry *)jarg1;
21898   if (!jarg2) {
21899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21900     return 0;
21901   }
21902   std::string arg2_str(jarg2);
21903   arg2 = &arg2_str;
21904   {
21905     try {
21906       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21907     } catch (std::out_of_range& e) {
21908       {
21909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21910       };
21911     } catch (std::exception& e) {
21912       {
21913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (Dali::DaliException e) {
21916       {
21917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925
21926   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21927
21928   //argout typemap for const std::string&
21929
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21935   void * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   std::type_info *arg2 = 0 ;
21938   Dali::TypeInfo result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (std::type_info *)jarg2;
21942   if (!arg2) {
21943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21944     return 0;
21945   }
21946   {
21947     try {
21948       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21949     } catch (std::out_of_range& e) {
21950       {
21951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (std::exception& e) {
21954       {
21955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21956       };
21957     } catch (Dali::DaliException e) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21960       };
21961     } catch (...) {
21962       {
21963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21964       };
21965     }
21966   }
21967
21968   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21969   return jresult;
21970 }
21971
21972
21973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21974   unsigned long jresult ;
21975   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21976   size_t result;
21977
21978   arg1 = (Dali::TypeRegistry *)jarg1;
21979   {
21980     try {
21981       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21982     } catch (std::out_of_range& e) {
21983       {
21984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21985       };
21986     } catch (std::exception& e) {
21987       {
21988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21989       };
21990     } catch (Dali::DaliException e) {
21991       {
21992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21993       };
21994     } catch (...) {
21995       {
21996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21997       };
21998     }
21999   }
22000
22001   jresult = (unsigned long)result;
22002   return jresult;
22003 }
22004
22005
22006 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
22007   char * jresult ;
22008   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
22009   size_t arg2 ;
22010   std::string result;
22011
22012   arg1 = (Dali::TypeRegistry *)jarg1;
22013   arg2 = (size_t)jarg2;
22014   {
22015     try {
22016       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
22017     } catch (std::out_of_range& e) {
22018       {
22019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22020       };
22021     } catch (std::exception& e) {
22022       {
22023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22024       };
22025     } catch (Dali::DaliException e) {
22026       {
22027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22028       };
22029     } catch (...) {
22030       {
22031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22032       };
22033     }
22034   }
22035
22036   jresult = SWIG_csharp_string_callback((&result)->c_str());
22037   return jresult;
22038 }
22039
22040
22041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22042   void * jresult ;
22043   std::type_info *arg1 = 0 ;
22044   std::type_info *arg2 = 0 ;
22045   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22046   Dali::TypeRegistration *result = 0 ;
22047
22048   arg1 = (std::type_info *)jarg1;
22049   if (!arg1) {
22050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22051     return 0;
22052   }
22053   arg2 = (std::type_info *)jarg2;
22054   if (!arg2) {
22055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22056     return 0;
22057   }
22058   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22059   {
22060     try {
22061       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22062     } catch (std::out_of_range& e) {
22063       {
22064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (std::exception& e) {
22067       {
22068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22069       };
22070     } catch (Dali::DaliException e) {
22071       {
22072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22077       };
22078     }
22079   }
22080
22081   jresult = (void *)result;
22082   return jresult;
22083 }
22084
22085
22086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22087   void * jresult ;
22088   std::type_info *arg1 = 0 ;
22089   std::type_info *arg2 = 0 ;
22090   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22091   bool arg4 ;
22092   Dali::TypeRegistration *result = 0 ;
22093
22094   arg1 = (std::type_info *)jarg1;
22095   if (!arg1) {
22096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22097     return 0;
22098   }
22099   arg2 = (std::type_info *)jarg2;
22100   if (!arg2) {
22101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22102     return 0;
22103   }
22104   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22105   arg4 = jarg4 ? true : false;
22106   {
22107     try {
22108       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22109     } catch (std::out_of_range& e) {
22110       {
22111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22112       };
22113     } catch (std::exception& e) {
22114       {
22115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22116       };
22117     } catch (Dali::DaliException e) {
22118       {
22119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22120       };
22121     } catch (...) {
22122       {
22123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22124       };
22125     }
22126   }
22127
22128   jresult = (void *)result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22134   void * jresult ;
22135   std::string *arg1 = 0 ;
22136   std::type_info *arg2 = 0 ;
22137   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22138   Dali::TypeRegistration *result = 0 ;
22139
22140   if (!jarg1) {
22141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22142     return 0;
22143   }
22144   std::string arg1_str(jarg1);
22145   arg1 = &arg1_str;
22146   arg2 = (std::type_info *)jarg2;
22147   if (!arg2) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22149     return 0;
22150   }
22151   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22152   {
22153     try {
22154       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22170       };
22171     }
22172   }
22173
22174   jresult = (void *)result;
22175
22176   //argout typemap for const std::string&
22177
22178   return jresult;
22179 }
22180
22181
22182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22183   char * jresult ;
22184   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22185   std::string result;
22186
22187   arg1 = (Dali::TypeRegistration *)jarg1;
22188   {
22189     try {
22190       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22191     } catch (std::out_of_range& e) {
22192       {
22193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22194       };
22195     } catch (std::exception& e) {
22196       {
22197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22198       };
22199     } catch (Dali::DaliException e) {
22200       {
22201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22202       };
22203     } catch (...) {
22204       {
22205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22206       };
22207     }
22208   }
22209
22210   jresult = SWIG_csharp_string_callback((&result)->c_str());
22211   return jresult;
22212 }
22213
22214
22215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22216   std::string *arg1 = 0 ;
22217   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22218
22219   if (!jarg1) {
22220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22221     return ;
22222   }
22223   std::string arg1_str(jarg1);
22224   arg1 = &arg1_str;
22225   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22226   {
22227     try {
22228       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22229     } catch (std::out_of_range& e) {
22230       {
22231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22232       };
22233     } catch (std::exception& e) {
22234       {
22235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22236       };
22237     } catch (Dali::DaliException e) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22240       };
22241     } catch (...) {
22242       {
22243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22244       };
22245     }
22246   }
22247
22248
22249   //argout typemap for const std::string&
22250
22251 }
22252
22253
22254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22255   std::string *arg1 = 0 ;
22256   std::string *arg2 = 0 ;
22257   int arg3 ;
22258   Dali::Property::Type arg4 ;
22259   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22260   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22261
22262   if (!jarg1) {
22263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22264     return ;
22265   }
22266   std::string arg1_str(jarg1);
22267   arg1 = &arg1_str;
22268   if (!jarg2) {
22269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22270     return ;
22271   }
22272   std::string arg2_str(jarg2);
22273   arg2 = &arg2_str;
22274   arg3 = (int)jarg3;
22275   arg4 = (Dali::Property::Type)jarg4;
22276   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22277   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22278   {
22279     try {
22280       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22281     } catch (std::out_of_range& e) {
22282       {
22283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22284       };
22285     } catch (std::exception& e) {
22286       {
22287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22288       };
22289     } catch (Dali::DaliException e) {
22290       {
22291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22292       };
22293     } catch (...) {
22294       {
22295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22296       };
22297     }
22298   }
22299
22300
22301   //argout typemap for const std::string&
22302
22303
22304   //argout typemap for const std::string&
22305
22306 }
22307
22308
22309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22310   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22311
22312   arg1 = (Dali::TypeRegistration *)jarg1;
22313   {
22314     try {
22315       delete arg1;
22316     } catch (std::out_of_range& e) {
22317       {
22318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22319       };
22320     } catch (std::exception& e) {
22321       {
22322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (Dali::DaliException e) {
22325       {
22326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22327       };
22328     } catch (...) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22331       };
22332     }
22333   }
22334
22335 }
22336
22337
22338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22339   void * jresult ;
22340   Dali::TypeRegistration *arg1 = 0 ;
22341   std::string *arg2 = 0 ;
22342   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22343   Dali::SignalConnectorType *result = 0 ;
22344
22345   arg1 = (Dali::TypeRegistration *)jarg1;
22346   if (!arg1) {
22347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22348     return 0;
22349   }
22350   if (!jarg2) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22352     return 0;
22353   }
22354   std::string arg2_str(jarg2);
22355   arg2 = &arg2_str;
22356   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22357   {
22358     try {
22359       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22360     } catch (std::out_of_range& e) {
22361       {
22362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22363       };
22364     } catch (std::exception& e) {
22365       {
22366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (Dali::DaliException e) {
22369       {
22370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22371       };
22372     } catch (...) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22375       };
22376     }
22377   }
22378
22379   jresult = (void *)result;
22380
22381   //argout typemap for const std::string&
22382
22383   return jresult;
22384 }
22385
22386
22387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22388   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22389
22390   arg1 = (Dali::SignalConnectorType *)jarg1;
22391   {
22392     try {
22393       delete arg1;
22394     } catch (std::out_of_range& e) {
22395       {
22396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22397       };
22398     } catch (std::exception& e) {
22399       {
22400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (Dali::DaliException e) {
22403       {
22404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22405       };
22406     } catch (...) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22409       };
22410     }
22411   }
22412
22413 }
22414
22415
22416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22417   void * jresult ;
22418   Dali::TypeRegistration *arg1 = 0 ;
22419   std::string *arg2 = 0 ;
22420   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22421   Dali::TypeAction *result = 0 ;
22422
22423   arg1 = (Dali::TypeRegistration *)jarg1;
22424   if (!arg1) {
22425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22426     return 0;
22427   }
22428   if (!jarg2) {
22429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22430     return 0;
22431   }
22432   std::string arg2_str(jarg2);
22433   arg2 = &arg2_str;
22434   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22435   {
22436     try {
22437       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22438     } catch (std::out_of_range& e) {
22439       {
22440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22441       };
22442     } catch (std::exception& e) {
22443       {
22444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22445       };
22446     } catch (Dali::DaliException e) {
22447       {
22448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22449       };
22450     } catch (...) {
22451       {
22452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22453       };
22454     }
22455   }
22456
22457   jresult = (void *)result;
22458
22459   //argout typemap for const std::string&
22460
22461   return jresult;
22462 }
22463
22464
22465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22466   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22467
22468   arg1 = (Dali::TypeAction *)jarg1;
22469   {
22470     try {
22471       delete arg1;
22472     } catch (std::out_of_range& e) {
22473       {
22474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22475       };
22476     } catch (std::exception& e) {
22477       {
22478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22479       };
22480     } catch (Dali::DaliException e) {
22481       {
22482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22483       };
22484     } catch (...) {
22485       {
22486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22487       };
22488     }
22489   }
22490
22491 }
22492
22493
22494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22495   void * jresult ;
22496   Dali::TypeRegistration *arg1 = 0 ;
22497   std::string *arg2 = 0 ;
22498   Dali::Property::Index arg3 ;
22499   Dali::Property::Type arg4 ;
22500   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22501   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22502   Dali::PropertyRegistration *result = 0 ;
22503
22504   arg1 = (Dali::TypeRegistration *)jarg1;
22505   if (!arg1) {
22506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22507     return 0;
22508   }
22509   if (!jarg2) {
22510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22511     return 0;
22512   }
22513   std::string arg2_str(jarg2);
22514   arg2 = &arg2_str;
22515   arg3 = (Dali::Property::Index)jarg3;
22516   arg4 = (Dali::Property::Type)jarg4;
22517   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22518   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22519   {
22520     try {
22521       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22522     } catch (std::out_of_range& e) {
22523       {
22524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22525       };
22526     } catch (std::exception& e) {
22527       {
22528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22529       };
22530     } catch (Dali::DaliException e) {
22531       {
22532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22533       };
22534     } catch (...) {
22535       {
22536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22537       };
22538     }
22539   }
22540
22541   jresult = (void *)result;
22542
22543   //argout typemap for const std::string&
22544
22545   return jresult;
22546 }
22547
22548
22549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22550   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22551
22552   arg1 = (Dali::PropertyRegistration *)jarg1;
22553   {
22554     try {
22555       delete arg1;
22556     } catch (std::out_of_range& e) {
22557       {
22558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22559       };
22560     } catch (std::exception& e) {
22561       {
22562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22563       };
22564     } catch (Dali::DaliException e) {
22565       {
22566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22567       };
22568     } catch (...) {
22569       {
22570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22571       };
22572     }
22573   }
22574
22575 }
22576
22577
22578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22579   void * jresult ;
22580   Dali::TypeRegistration *arg1 = 0 ;
22581   std::string *arg2 = 0 ;
22582   Dali::Property::Index arg3 ;
22583   Dali::Property::Type arg4 ;
22584   Dali::AnimatablePropertyRegistration *result = 0 ;
22585
22586   arg1 = (Dali::TypeRegistration *)jarg1;
22587   if (!arg1) {
22588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22589     return 0;
22590   }
22591   if (!jarg2) {
22592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22593     return 0;
22594   }
22595   std::string arg2_str(jarg2);
22596   arg2 = &arg2_str;
22597   arg3 = (Dali::Property::Index)jarg3;
22598   arg4 = (Dali::Property::Type)jarg4;
22599   {
22600     try {
22601       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22602     } catch (std::out_of_range& e) {
22603       {
22604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22605       };
22606     } catch (std::exception& e) {
22607       {
22608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22609       };
22610     } catch (Dali::DaliException e) {
22611       {
22612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22613       };
22614     } catch (...) {
22615       {
22616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22617       };
22618     }
22619   }
22620
22621   jresult = (void *)result;
22622
22623   //argout typemap for const std::string&
22624
22625   return jresult;
22626 }
22627
22628
22629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22630   void * jresult ;
22631   Dali::TypeRegistration *arg1 = 0 ;
22632   std::string *arg2 = 0 ;
22633   Dali::Property::Index arg3 ;
22634   Dali::Property::Value *arg4 = 0 ;
22635   Dali::AnimatablePropertyRegistration *result = 0 ;
22636
22637   arg1 = (Dali::TypeRegistration *)jarg1;
22638   if (!arg1) {
22639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22640     return 0;
22641   }
22642   if (!jarg2) {
22643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22644     return 0;
22645   }
22646   std::string arg2_str(jarg2);
22647   arg2 = &arg2_str;
22648   arg3 = (Dali::Property::Index)jarg3;
22649   arg4 = (Dali::Property::Value *)jarg4;
22650   if (!arg4) {
22651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22652     return 0;
22653   }
22654   {
22655     try {
22656       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22657     } catch (std::out_of_range& e) {
22658       {
22659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22660       };
22661     } catch (std::exception& e) {
22662       {
22663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (Dali::DaliException e) {
22666       {
22667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22668       };
22669     } catch (...) {
22670       {
22671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22672       };
22673     }
22674   }
22675
22676   jresult = (void *)result;
22677
22678   //argout typemap for const std::string&
22679
22680   return jresult;
22681 }
22682
22683
22684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22685   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22686
22687   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22688   {
22689     try {
22690       delete arg1;
22691     } catch (std::out_of_range& e) {
22692       {
22693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22694       };
22695     } catch (std::exception& e) {
22696       {
22697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22698       };
22699     } catch (Dali::DaliException e) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22702       };
22703     } catch (...) {
22704       {
22705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22706       };
22707     }
22708   }
22709
22710 }
22711
22712
22713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22714   void * jresult ;
22715   Dali::TypeRegistration *arg1 = 0 ;
22716   std::string *arg2 = 0 ;
22717   Dali::Property::Index arg3 ;
22718   Dali::Property::Index arg4 ;
22719   unsigned int arg5 ;
22720   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22721
22722   arg1 = (Dali::TypeRegistration *)jarg1;
22723   if (!arg1) {
22724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22725     return 0;
22726   }
22727   if (!jarg2) {
22728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22729     return 0;
22730   }
22731   std::string arg2_str(jarg2);
22732   arg2 = &arg2_str;
22733   arg3 = (Dali::Property::Index)jarg3;
22734   arg4 = (Dali::Property::Index)jarg4;
22735   arg5 = (unsigned int)jarg5;
22736   {
22737     try {
22738       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22739     } catch (std::out_of_range& e) {
22740       {
22741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22742       };
22743     } catch (std::exception& e) {
22744       {
22745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22746       };
22747     } catch (Dali::DaliException e) {
22748       {
22749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22750       };
22751     } catch (...) {
22752       {
22753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22754       };
22755     }
22756   }
22757
22758   jresult = (void *)result;
22759
22760   //argout typemap for const std::string&
22761
22762   return jresult;
22763 }
22764
22765
22766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22767   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22768
22769   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22770   {
22771     try {
22772       delete arg1;
22773     } catch (std::out_of_range& e) {
22774       {
22775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22776       };
22777     } catch (std::exception& e) {
22778       {
22779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22780       };
22781     } catch (Dali::DaliException e) {
22782       {
22783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22784       };
22785     } catch (...) {
22786       {
22787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22788       };
22789     }
22790   }
22791
22792 }
22793
22794
22795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22796   void * jresult ;
22797   Dali::TypeRegistration *arg1 = 0 ;
22798   std::string *arg2 = 0 ;
22799   Dali::Property::Index arg3 ;
22800   Dali::Property::Type arg4 ;
22801   Dali::ChildPropertyRegistration *result = 0 ;
22802
22803   arg1 = (Dali::TypeRegistration *)jarg1;
22804   if (!arg1) {
22805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22806     return 0;
22807   }
22808   if (!jarg2) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg2_str(jarg2);
22813   arg2 = &arg2_str;
22814   arg3 = (Dali::Property::Index)jarg3;
22815   arg4 = (Dali::Property::Type)jarg4;
22816   {
22817     try {
22818       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22819     } catch (std::out_of_range& e) {
22820       {
22821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (std::exception& e) {
22824       {
22825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (Dali::DaliException e) {
22828       {
22829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22830       };
22831     } catch (...) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22834       };
22835     }
22836   }
22837
22838   jresult = (void *)result;
22839
22840   //argout typemap for const std::string&
22841
22842   return jresult;
22843 }
22844
22845
22846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22847   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22848
22849   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22850   {
22851     try {
22852       delete arg1;
22853     } catch (std::out_of_range& e) {
22854       {
22855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22856       };
22857     } catch (std::exception& e) {
22858       {
22859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22860       };
22861     } catch (Dali::DaliException e) {
22862       {
22863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22864       };
22865     } catch (...) {
22866       {
22867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22868       };
22869     }
22870   }
22871
22872 }
22873
22874
22875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22876   unsigned int jresult ;
22877   std::string *arg1 = 0 ;
22878   std::type_info *arg2 = 0 ;
22879   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22880   bool result;
22881
22882   if (!jarg1) {
22883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22884     return 0;
22885   }
22886   std::string arg1_str(jarg1);
22887   arg1 = &arg1_str;
22888   arg2 = (std::type_info *)jarg2;
22889   if (!arg2) {
22890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22891     return 0;
22892   }
22893   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22894   {
22895     try {
22896       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (Dali::DaliException e) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22908       };
22909     } catch (...) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22912       };
22913     }
22914   }
22915
22916   jresult = result;
22917
22918   //argout typemap for const std::string&
22919
22920   return jresult;
22921 }
22922
22923
22924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22925   unsigned int jresult ;
22926   std::string *arg1 = 0 ;
22927   std::string *arg2 = 0 ;
22928   Dali::Property::Index arg3 ;
22929   Dali::Property::Type arg4 ;
22930   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22931   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22932   bool result;
22933
22934   if (!jarg1) {
22935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22936     return 0;
22937   }
22938   std::string arg1_str(jarg1);
22939   arg1 = &arg1_str;
22940   if (!jarg2) {
22941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22942     return 0;
22943   }
22944   std::string arg2_str(jarg2);
22945   arg2 = &arg2_str;
22946   arg3 = (Dali::Property::Index)jarg3;
22947   arg4 = (Dali::Property::Type)jarg4;
22948   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22949   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22950   {
22951     try {
22952       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22953     } catch (std::out_of_range& e) {
22954       {
22955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22956       };
22957     } catch (std::exception& e) {
22958       {
22959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22960       };
22961     } catch (Dali::DaliException e) {
22962       {
22963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22964       };
22965     } catch (...) {
22966       {
22967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22968       };
22969     }
22970   }
22971
22972   jresult = result;
22973
22974   //argout typemap for const std::string&
22975
22976
22977   //argout typemap for const std::string&
22978
22979   return jresult;
22980 }
22981
22982
22983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22984   float jresult ;
22985   float result;
22986
22987   result = (float)(float)Dali::ParentOrigin::TOP;
22988   jresult = result;
22989   return jresult;
22990 }
22991
22992
22993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22994   float jresult ;
22995   float result;
22996
22997   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22998   jresult = result;
22999   return jresult;
23000 }
23001
23002
23003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
23004   float jresult ;
23005   float result;
23006
23007   result = (float)(float)Dali::ParentOrigin::LEFT;
23008   jresult = result;
23009   return jresult;
23010 }
23011
23012
23013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
23014   float jresult ;
23015   float result;
23016
23017   result = (float)(float)Dali::ParentOrigin::RIGHT;
23018   jresult = result;
23019   return jresult;
23020 }
23021
23022
23023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23024   float jresult ;
23025   float result;
23026
23027   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23028   jresult = result;
23029   return jresult;
23030 }
23031
23032
23033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23034   void * jresult ;
23035   Dali::Vector3 *result = 0 ;
23036
23037   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23038   jresult = (void *)result;
23039   return jresult;
23040 }
23041
23042
23043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23044   void * jresult ;
23045   Dali::Vector3 *result = 0 ;
23046
23047   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23048   jresult = (void *)result;
23049   return jresult;
23050 }
23051
23052
23053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23054   void * jresult ;
23055   Dali::Vector3 *result = 0 ;
23056
23057   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23058   jresult = (void *)result;
23059   return jresult;
23060 }
23061
23062
23063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23064   void * jresult ;
23065   Dali::Vector3 *result = 0 ;
23066
23067   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23068   jresult = (void *)result;
23069   return jresult;
23070 }
23071
23072
23073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23074   void * jresult ;
23075   Dali::Vector3 *result = 0 ;
23076
23077   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23078   jresult = (void *)result;
23079   return jresult;
23080 }
23081
23082
23083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23084   void * jresult ;
23085   Dali::Vector3 *result = 0 ;
23086
23087   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23088   jresult = (void *)result;
23089   return jresult;
23090 }
23091
23092
23093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23094   void * jresult ;
23095   Dali::Vector3 *result = 0 ;
23096
23097   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23098   jresult = (void *)result;
23099   return jresult;
23100 }
23101
23102
23103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23104   void * jresult ;
23105   Dali::Vector3 *result = 0 ;
23106
23107   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23108   jresult = (void *)result;
23109   return jresult;
23110 }
23111
23112
23113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23114   void * jresult ;
23115   Dali::Vector3 *result = 0 ;
23116
23117   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23118   jresult = (void *)result;
23119   return jresult;
23120 }
23121
23122
23123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23124   float jresult ;
23125   float result;
23126
23127   result = (float)(float)Dali::AnchorPoint::TOP;
23128   jresult = result;
23129   return jresult;
23130 }
23131
23132
23133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23134   float jresult ;
23135   float result;
23136
23137   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23138   jresult = result;
23139   return jresult;
23140 }
23141
23142
23143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23144   float jresult ;
23145   float result;
23146
23147   result = (float)(float)Dali::AnchorPoint::LEFT;
23148   jresult = result;
23149   return jresult;
23150 }
23151
23152
23153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23154   float jresult ;
23155   float result;
23156
23157   result = (float)(float)Dali::AnchorPoint::RIGHT;
23158   jresult = result;
23159   return jresult;
23160 }
23161
23162
23163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23164   float jresult ;
23165   float result;
23166
23167   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23168   jresult = result;
23169   return jresult;
23170 }
23171
23172
23173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23174   void * jresult ;
23175   Dali::Vector3 *result = 0 ;
23176
23177   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23178   jresult = (void *)result;
23179   return jresult;
23180 }
23181
23182
23183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23184   void * jresult ;
23185   Dali::Vector3 *result = 0 ;
23186
23187   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23188   jresult = (void *)result;
23189   return jresult;
23190 }
23191
23192
23193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23194   void * jresult ;
23195   Dali::Vector3 *result = 0 ;
23196
23197   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23198   jresult = (void *)result;
23199   return jresult;
23200 }
23201
23202
23203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23204   void * jresult ;
23205   Dali::Vector3 *result = 0 ;
23206
23207   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23208   jresult = (void *)result;
23209   return jresult;
23210 }
23211
23212
23213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23214   void * jresult ;
23215   Dali::Vector3 *result = 0 ;
23216
23217   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23218   jresult = (void *)result;
23219   return jresult;
23220 }
23221
23222
23223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23224   void * jresult ;
23225   Dali::Vector3 *result = 0 ;
23226
23227   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23228   jresult = (void *)result;
23229   return jresult;
23230 }
23231
23232
23233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23234   void * jresult ;
23235   Dali::Vector3 *result = 0 ;
23236
23237   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23238   jresult = (void *)result;
23239   return jresult;
23240 }
23241
23242
23243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23244   void * jresult ;
23245   Dali::Vector3 *result = 0 ;
23246
23247   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23248   jresult = (void *)result;
23249   return jresult;
23250 }
23251
23252
23253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23254   void * jresult ;
23255   Dali::Vector3 *result = 0 ;
23256
23257   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23258   jresult = (void *)result;
23259   return jresult;
23260 }
23261
23262
23263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23264   void * jresult ;
23265   Dali::Vector4 *result = 0 ;
23266
23267   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23268   jresult = (void *)result;
23269   return jresult;
23270 }
23271
23272
23273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23274   void * jresult ;
23275   Dali::Vector4 *result = 0 ;
23276
23277   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23278   jresult = (void *)result;
23279   return jresult;
23280 }
23281
23282
23283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23284   void * jresult ;
23285   Dali::Vector4 *result = 0 ;
23286
23287   result = (Dali::Vector4 *)&Dali::Color::RED;
23288   jresult = (void *)result;
23289   return jresult;
23290 }
23291
23292
23293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23294   void * jresult ;
23295   Dali::Vector4 *result = 0 ;
23296
23297   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23298   jresult = (void *)result;
23299   return jresult;
23300 }
23301
23302
23303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23304   void * jresult ;
23305   Dali::Vector4 *result = 0 ;
23306
23307   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23308   jresult = (void *)result;
23309   return jresult;
23310 }
23311
23312
23313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23314   void * jresult ;
23315   Dali::Vector4 *result = 0 ;
23316
23317   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23318   jresult = (void *)result;
23319   return jresult;
23320 }
23321
23322
23323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23324   void * jresult ;
23325   Dali::Vector4 *result = 0 ;
23326
23327   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23328   jresult = (void *)result;
23329   return jresult;
23330 }
23331
23332
23333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23334   void * jresult ;
23335   Dali::Vector4 *result = 0 ;
23336
23337   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23338   jresult = (void *)result;
23339   return jresult;
23340 }
23341
23342
23343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23344   void * jresult ;
23345   Dali::Vector4 *result = 0 ;
23346
23347   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23348   jresult = (void *)result;
23349   return jresult;
23350 }
23351
23352
23353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23354   float jresult ;
23355   float result;
23356
23357   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23358   jresult = result;
23359   return jresult;
23360 }
23361
23362
23363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23364   float jresult ;
23365   float result;
23366
23367   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23368   jresult = result;
23369   return jresult;
23370 }
23371
23372
23373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23374   float jresult ;
23375   float result;
23376
23377   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23378   jresult = result;
23379   return jresult;
23380 }
23381
23382
23383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23384   float jresult ;
23385   float result;
23386
23387   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23388   jresult = result;
23389   return jresult;
23390 }
23391
23392
23393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23394   float jresult ;
23395   float result;
23396
23397   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23398   jresult = result;
23399   return jresult;
23400 }
23401
23402
23403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23404   float jresult ;
23405   float result;
23406
23407   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23408   jresult = result;
23409   return jresult;
23410 }
23411
23412
23413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23414   float jresult ;
23415   float result;
23416
23417   result = (float)(float)Dali::Math::PI;
23418   jresult = result;
23419   return jresult;
23420 }
23421
23422
23423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23424   float jresult ;
23425   float result;
23426
23427   result = (float)(float)Dali::Math::PI_2;
23428   jresult = result;
23429   return jresult;
23430 }
23431
23432
23433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23434   float jresult ;
23435   float result;
23436
23437   result = (float)(float)Dali::Math::PI_4;
23438   jresult = result;
23439   return jresult;
23440 }
23441
23442
23443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23444   float jresult ;
23445   float result;
23446
23447   result = (float)(float)Dali::Math::PI_OVER_180;
23448   jresult = result;
23449   return jresult;
23450 }
23451
23452
23453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23454   float jresult ;
23455   float result;
23456
23457   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23458   jresult = result;
23459   return jresult;
23460 }
23461
23462
23463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23464   int jresult ;
23465   Dali::ResizePolicy::Type result;
23466
23467   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23468   jresult = (int)result;
23469   return jresult;
23470 }
23471
23472
23473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23474   unsigned long jresult ;
23475   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23476   Dali::VectorBase::SizeType result;
23477
23478   arg1 = (Dali::VectorBase *)jarg1;
23479   {
23480     try {
23481       result = ((Dali::VectorBase const *)arg1)->Count();
23482     } catch (std::out_of_range& e) {
23483       {
23484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23485       };
23486     } catch (std::exception& e) {
23487       {
23488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23489       };
23490     } catch (Dali::DaliException e) {
23491       {
23492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23493       };
23494     } catch (...) {
23495       {
23496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23497       };
23498     }
23499   }
23500
23501   jresult = (unsigned long)result;
23502   return jresult;
23503 }
23504
23505
23506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23507   unsigned long jresult ;
23508   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23509   Dali::VectorBase::SizeType result;
23510
23511   arg1 = (Dali::VectorBase *)jarg1;
23512   {
23513     try {
23514       result = ((Dali::VectorBase const *)arg1)->Size();
23515     } catch (std::out_of_range& e) {
23516       {
23517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23518       };
23519     } catch (std::exception& e) {
23520       {
23521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23522       };
23523     } catch (Dali::DaliException e) {
23524       {
23525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23526       };
23527     } catch (...) {
23528       {
23529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23530       };
23531     }
23532   }
23533
23534   jresult = (unsigned long)result;
23535   return jresult;
23536 }
23537
23538
23539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23540   unsigned int jresult ;
23541   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23542   bool result;
23543
23544   arg1 = (Dali::VectorBase *)jarg1;
23545   {
23546     try {
23547       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23548     } catch (std::out_of_range& e) {
23549       {
23550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23551       };
23552     } catch (std::exception& e) {
23553       {
23554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23555       };
23556     } catch (Dali::DaliException e) {
23557       {
23558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23559       };
23560     } catch (...) {
23561       {
23562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23563       };
23564     }
23565   }
23566
23567   jresult = result;
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23573   unsigned long jresult ;
23574   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23575   Dali::VectorBase::SizeType result;
23576
23577   arg1 = (Dali::VectorBase *)jarg1;
23578   {
23579     try {
23580       result = ((Dali::VectorBase const *)arg1)->Capacity();
23581     } catch (std::out_of_range& e) {
23582       {
23583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23584       };
23585     } catch (std::exception& e) {
23586       {
23587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23588       };
23589     } catch (Dali::DaliException e) {
23590       {
23591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23592       };
23593     } catch (...) {
23594       {
23595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23596       };
23597     }
23598   }
23599
23600   jresult = (unsigned long)result;
23601   return jresult;
23602 }
23603
23604
23605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23606   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23607
23608   arg1 = (Dali::VectorBase *)jarg1;
23609   {
23610     try {
23611       (arg1)->Release();
23612     } catch (std::out_of_range& e) {
23613       {
23614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23615       };
23616     } catch (std::exception& e) {
23617       {
23618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23619       };
23620     } catch (Dali::DaliException e) {
23621       {
23622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23623       };
23624     } catch (...) {
23625       {
23626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23627       };
23628     }
23629   }
23630
23631 }
23632
23633
23634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23635   void * jresult ;
23636   Dali::Image *result = 0 ;
23637
23638   {
23639     try {
23640       result = (Dali::Image *)new Dali::Image();
23641     } catch (std::out_of_range& e) {
23642       {
23643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23644       };
23645     } catch (std::exception& e) {
23646       {
23647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23648       };
23649     } catch (Dali::DaliException e) {
23650       {
23651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23652       };
23653     } catch (...) {
23654       {
23655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23656       };
23657     }
23658   }
23659
23660   jresult = (void *)result;
23661   return jresult;
23662 }
23663
23664
23665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23666   Dali::Image *arg1 = (Dali::Image *) 0 ;
23667
23668   arg1 = (Dali::Image *)jarg1;
23669   {
23670     try {
23671       delete arg1;
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23687       };
23688     }
23689   }
23690
23691 }
23692
23693
23694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23695   void * jresult ;
23696   Dali::Image *arg1 = 0 ;
23697   Dali::Image *result = 0 ;
23698
23699   arg1 = (Dali::Image *)jarg1;
23700   if (!arg1) {
23701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23702     return 0;
23703   }
23704   {
23705     try {
23706       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23707     } catch (std::out_of_range& e) {
23708       {
23709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23710       };
23711     } catch (std::exception& e) {
23712       {
23713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (Dali::DaliException e) {
23716       {
23717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23718       };
23719     } catch (...) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23722       };
23723     }
23724   }
23725
23726   jresult = (void *)result;
23727   return jresult;
23728 }
23729
23730
23731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23732   void * jresult ;
23733   Dali::Image *arg1 = (Dali::Image *) 0 ;
23734   Dali::Image *arg2 = 0 ;
23735   Dali::Image *result = 0 ;
23736
23737   arg1 = (Dali::Image *)jarg1;
23738   arg2 = (Dali::Image *)jarg2;
23739   if (!arg2) {
23740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23741     return 0;
23742   }
23743   {
23744     try {
23745       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23753       };
23754     } catch (Dali::DaliException e) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23761       };
23762     }
23763   }
23764
23765   jresult = (void *)result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23771   void * jresult ;
23772   Dali::BaseHandle arg1 ;
23773   Dali::BaseHandle *argp1 ;
23774   Dali::Image result;
23775
23776   argp1 = (Dali::BaseHandle *)jarg1;
23777   if (!argp1) {
23778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23779     return 0;
23780   }
23781   arg1 = *argp1;
23782   {
23783     try {
23784       result = Dali::Image::DownCast(arg1);
23785     } catch (std::out_of_range& e) {
23786       {
23787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23788       };
23789     } catch (std::exception& e) {
23790       {
23791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23792       };
23793     } catch (Dali::DaliException e) {
23794       {
23795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23796       };
23797     } catch (...) {
23798       {
23799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23800       };
23801     }
23802   }
23803
23804   jresult = new Dali::Image((const Dali::Image &)result);
23805   return jresult;
23806 }
23807
23808
23809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23810   unsigned int jresult ;
23811   Dali::Image *arg1 = (Dali::Image *) 0 ;
23812   unsigned int result;
23813
23814   arg1 = (Dali::Image *)jarg1;
23815   {
23816     try {
23817       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23818     } catch (std::out_of_range& e) {
23819       {
23820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23821       };
23822     } catch (std::exception& e) {
23823       {
23824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23825       };
23826     } catch (Dali::DaliException e) {
23827       {
23828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23829       };
23830     } catch (...) {
23831       {
23832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23833       };
23834     }
23835   }
23836
23837   jresult = result;
23838   return jresult;
23839 }
23840
23841
23842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23843   unsigned int jresult ;
23844   Dali::Image *arg1 = (Dali::Image *) 0 ;
23845   unsigned int result;
23846
23847   arg1 = (Dali::Image *)jarg1;
23848   {
23849     try {
23850       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23851     } catch (std::out_of_range& e) {
23852       {
23853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23854       };
23855     } catch (std::exception& e) {
23856       {
23857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23858       };
23859     } catch (Dali::DaliException e) {
23860       {
23861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23862       };
23863     } catch (...) {
23864       {
23865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23866       };
23867     }
23868   }
23869
23870   jresult = result;
23871   return jresult;
23872 }
23873
23874
23875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23876   void * jresult ;
23877   Dali::Image *arg1 = (Dali::Image *) 0 ;
23878   Dali::Image::ImageSignalType *result = 0 ;
23879
23880   arg1 = (Dali::Image *)jarg1;
23881   {
23882     try {
23883       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23884     } catch (std::out_of_range& e) {
23885       {
23886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23887       };
23888     } catch (std::exception& e) {
23889       {
23890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23891       };
23892     } catch (Dali::DaliException e) {
23893       {
23894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23895       };
23896     } catch (...) {
23897       {
23898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23899       };
23900     }
23901   }
23902
23903   jresult = (void *)result;
23904   return jresult;
23905 }
23906
23907
23908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23909   int jresult ;
23910   Dali::Pixel::Format result;
23911
23912   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23913   jresult = (int)result;
23914   return jresult;
23915 }
23916
23917
23918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23919   int jresult ;
23920   Dali::Pixel::Format result;
23921
23922   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23923   jresult = (int)result;
23924   return jresult;
23925 }
23926
23927
23928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23929   unsigned int jresult ;
23930   Dali::Pixel::Format arg1 ;
23931   bool result;
23932
23933   arg1 = (Dali::Pixel::Format)jarg1;
23934   {
23935     try {
23936       result = (bool)Dali::Pixel::HasAlpha(arg1);
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23944       };
23945     } catch (Dali::DaliException e) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23952       };
23953     }
23954   }
23955
23956   jresult = result;
23957   return jresult;
23958 }
23959
23960
23961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23962   unsigned int jresult ;
23963   Dali::Pixel::Format arg1 ;
23964   unsigned int result;
23965
23966   arg1 = (Dali::Pixel::Format)jarg1;
23967   {
23968     try {
23969       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23970     } catch (std::out_of_range& e) {
23971       {
23972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23973       };
23974     } catch (std::exception& e) {
23975       {
23976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23977       };
23978     } catch (Dali::DaliException e) {
23979       {
23980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23981       };
23982     } catch (...) {
23983       {
23984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23985       };
23986     }
23987   }
23988
23989   jresult = result;
23990   return jresult;
23991 }
23992
23993
23994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23995   Dali::Pixel::Format arg1 ;
23996   int *arg2 = 0 ;
23997   int *arg3 = 0 ;
23998
23999   arg1 = (Dali::Pixel::Format)jarg1;
24000   arg2 = (int *)jarg2;
24001   if (!arg2) {
24002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24003     return ;
24004   }
24005   arg3 = (int *)jarg3;
24006   if (!arg3) {
24007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24008     return ;
24009   }
24010   {
24011     try {
24012       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24028       };
24029     }
24030   }
24031
24032 }
24033
24034
24035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
24036   void * jresult ;
24037   unsigned char *arg1 = (unsigned char *) 0 ;
24038   unsigned int arg2 ;
24039   unsigned int arg3 ;
24040   unsigned int arg4 ;
24041   Dali::Pixel::Format arg5 ;
24042   Dali::PixelData::ReleaseFunction arg6 ;
24043   Dali::PixelData result;
24044
24045   arg1 = jarg1;
24046   arg2 = (unsigned int)jarg2;
24047   arg3 = (unsigned int)jarg3;
24048   arg4 = (unsigned int)jarg4;
24049   arg5 = (Dali::Pixel::Format)jarg5;
24050   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24051   {
24052     try {
24053       auto pixelBuffer = new unsigned char[jarg2];
24054       memcpy( pixelBuffer, arg1, arg2);
24055       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
24056     } catch (std::out_of_range& e) {
24057       {
24058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24059       };
24060     } catch (std::exception& e) {
24061       {
24062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24063       };
24064     } catch (Dali::DaliException e) {
24065       {
24066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24067       };
24068     } catch (...) {
24069       {
24070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24071       };
24072     }
24073   }
24074
24075   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24076
24077
24078   return jresult;
24079 }
24080
24081
24082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24083   void * jresult ;
24084   Dali::PixelData *result = 0 ;
24085
24086   {
24087     try {
24088       result = (Dali::PixelData *)new Dali::PixelData();
24089     } catch (std::out_of_range& e) {
24090       {
24091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24092       };
24093     } catch (std::exception& e) {
24094       {
24095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24096       };
24097     } catch (Dali::DaliException e) {
24098       {
24099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24104       };
24105     }
24106   }
24107
24108   jresult = (void *)result;
24109   return jresult;
24110 }
24111
24112
24113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24114   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24115
24116   arg1 = (Dali::PixelData *)jarg1;
24117   {
24118     try {
24119       delete arg1;
24120     } catch (std::out_of_range& e) {
24121       {
24122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24123       };
24124     } catch (std::exception& e) {
24125       {
24126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24127       };
24128     } catch (Dali::DaliException e) {
24129       {
24130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24131       };
24132     } catch (...) {
24133       {
24134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24135       };
24136     }
24137   }
24138
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24143   void * jresult ;
24144   Dali::PixelData *arg1 = 0 ;
24145   Dali::PixelData *result = 0 ;
24146
24147   arg1 = (Dali::PixelData *)jarg1;
24148   if (!arg1) {
24149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24150     return 0;
24151   }
24152   {
24153     try {
24154       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (Dali::DaliException e) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24166       };
24167     } catch (...) {
24168       {
24169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24170       };
24171     }
24172   }
24173
24174   jresult = (void *)result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24180   void * jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   Dali::PixelData *arg2 = 0 ;
24183   Dali::PixelData *result = 0 ;
24184
24185   arg1 = (Dali::PixelData *)jarg1;
24186   arg2 = (Dali::PixelData *)jarg2;
24187   if (!arg2) {
24188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24189     return 0;
24190   }
24191   {
24192     try {
24193       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24194     } catch (std::out_of_range& e) {
24195       {
24196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24197       };
24198     } catch (std::exception& e) {
24199       {
24200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24201       };
24202     } catch (Dali::DaliException e) {
24203       {
24204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24205       };
24206     } catch (...) {
24207       {
24208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24209       };
24210     }
24211   }
24212
24213   jresult = (void *)result;
24214   return jresult;
24215 }
24216
24217
24218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24219   unsigned int jresult ;
24220   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24221   unsigned int result;
24222
24223   arg1 = (Dali::PixelData *)jarg1;
24224   {
24225     try {
24226       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24227     } catch (std::out_of_range& e) {
24228       {
24229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24230       };
24231     } catch (std::exception& e) {
24232       {
24233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24234       };
24235     } catch (Dali::DaliException e) {
24236       {
24237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24238       };
24239     } catch (...) {
24240       {
24241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24242       };
24243     }
24244   }
24245
24246   jresult = result;
24247   return jresult;
24248 }
24249
24250
24251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24252   unsigned int jresult ;
24253   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24254   unsigned int result;
24255
24256   arg1 = (Dali::PixelData *)jarg1;
24257   {
24258     try {
24259       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24260     } catch (std::out_of_range& e) {
24261       {
24262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24263       };
24264     } catch (std::exception& e) {
24265       {
24266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24267       };
24268     } catch (Dali::DaliException e) {
24269       {
24270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24271       };
24272     } catch (...) {
24273       {
24274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24275       };
24276     }
24277   }
24278
24279   jresult = result;
24280   return jresult;
24281 }
24282
24283
24284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24285   int jresult ;
24286   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24287   Dali::Pixel::Format result;
24288
24289   arg1 = (Dali::PixelData *)jarg1;
24290   {
24291     try {
24292       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24293     } catch (std::out_of_range& e) {
24294       {
24295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24296       };
24297     } catch (std::exception& e) {
24298       {
24299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24300       };
24301     } catch (Dali::DaliException e) {
24302       {
24303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24304       };
24305     } catch (...) {
24306       {
24307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24308       };
24309     }
24310   }
24311
24312   jresult = (int)result;
24313   return jresult;
24314 }
24315
24316
24317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24318   unsigned int jresult ;
24319   unsigned int result;
24320
24321   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24322   jresult = result;
24323   return jresult;
24324 }
24325
24326
24327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24328   unsigned int jresult ;
24329   unsigned int result;
24330
24331   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24332   jresult = result;
24333   return jresult;
24334 }
24335
24336
24337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24338   unsigned int jresult ;
24339   unsigned int result;
24340
24341   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24342   jresult = result;
24343   return jresult;
24344 }
24345
24346
24347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24348   unsigned int jresult ;
24349   unsigned int result;
24350
24351   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24352   jresult = result;
24353   return jresult;
24354 }
24355
24356
24357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24358   unsigned int jresult ;
24359   unsigned int result;
24360
24361   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24362   jresult = result;
24363   return jresult;
24364 }
24365
24366
24367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24368   unsigned int jresult ;
24369   unsigned int result;
24370
24371   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24372   jresult = result;
24373   return jresult;
24374 }
24375
24376
24377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24378   void * jresult ;
24379   Dali::TextureType::Type arg1 ;
24380   Dali::Pixel::Format arg2 ;
24381   unsigned int arg3 ;
24382   unsigned int arg4 ;
24383   Dali::Texture result;
24384
24385   arg1 = (Dali::TextureType::Type)jarg1;
24386   arg2 = (Dali::Pixel::Format)jarg2;
24387   arg3 = (unsigned int)jarg3;
24388   arg4 = (unsigned int)jarg4;
24389   {
24390     try {
24391       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24392     } catch (std::out_of_range& e) {
24393       {
24394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (std::exception& e) {
24397       {
24398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24399       };
24400     } catch (Dali::DaliException e) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24403       };
24404     } catch (...) {
24405       {
24406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24407       };
24408     }
24409   }
24410
24411   jresult = new Dali::Texture((const Dali::Texture &)result);
24412   return jresult;
24413 }
24414
24415
24416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24417   void * jresult ;
24418   NativeImageInterface *arg1 = 0 ;
24419   Dali::Texture result;
24420
24421   arg1 = (NativeImageInterface *)jarg1;
24422   if (!arg1) {
24423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24424     return 0;
24425   }
24426   {
24427     try {
24428       result = Dali::Texture::New(*arg1);
24429     } catch (std::out_of_range& e) {
24430       {
24431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24432       };
24433     } catch (std::exception& e) {
24434       {
24435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24436       };
24437     } catch (Dali::DaliException e) {
24438       {
24439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24440       };
24441     } catch (...) {
24442       {
24443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24444       };
24445     }
24446   }
24447
24448   jresult = new Dali::Texture((const Dali::Texture &)result);
24449   return jresult;
24450 }
24451
24452
24453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24454   void * jresult ;
24455   Dali::Texture *result = 0 ;
24456
24457   {
24458     try {
24459       result = (Dali::Texture *)new Dali::Texture();
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24467       };
24468     } catch (Dali::DaliException e) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24471       };
24472     } catch (...) {
24473       {
24474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24475       };
24476     }
24477   }
24478
24479   jresult = (void *)result;
24480   return jresult;
24481 }
24482
24483
24484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24485   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24486
24487   arg1 = (Dali::Texture *)jarg1;
24488   {
24489     try {
24490       delete arg1;
24491     } catch (std::out_of_range& e) {
24492       {
24493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24494       };
24495     } catch (std::exception& e) {
24496       {
24497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24498       };
24499     } catch (Dali::DaliException e) {
24500       {
24501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24506       };
24507     }
24508   }
24509
24510 }
24511
24512
24513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24514   void * jresult ;
24515   Dali::Texture *arg1 = 0 ;
24516   Dali::Texture *result = 0 ;
24517
24518   arg1 = (Dali::Texture *)jarg1;
24519   if (!arg1) {
24520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24521     return 0;
24522   }
24523   {
24524     try {
24525       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24526     } catch (std::out_of_range& e) {
24527       {
24528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24529       };
24530     } catch (std::exception& e) {
24531       {
24532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (Dali::DaliException e) {
24535       {
24536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24537       };
24538     } catch (...) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24541       };
24542     }
24543   }
24544
24545   jresult = (void *)result;
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24551   void * jresult ;
24552   Dali::BaseHandle arg1 ;
24553   Dali::BaseHandle *argp1 ;
24554   Dali::Texture result;
24555
24556   argp1 = (Dali::BaseHandle *)jarg1;
24557   if (!argp1) {
24558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24559     return 0;
24560   }
24561   arg1 = *argp1;
24562   {
24563     try {
24564       result = Dali::Texture::DownCast(arg1);
24565     } catch (std::out_of_range& e) {
24566       {
24567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24568       };
24569     } catch (std::exception& e) {
24570       {
24571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (Dali::DaliException e) {
24574       {
24575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24576       };
24577     } catch (...) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24580       };
24581     }
24582   }
24583
24584   jresult = new Dali::Texture((const Dali::Texture &)result);
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24590   void * jresult ;
24591   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24592   Dali::Texture *arg2 = 0 ;
24593   Dali::Texture *result = 0 ;
24594
24595   arg1 = (Dali::Texture *)jarg1;
24596   arg2 = (Dali::Texture *)jarg2;
24597   if (!arg2) {
24598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24599     return 0;
24600   }
24601   {
24602     try {
24603       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24604     } catch (std::out_of_range& e) {
24605       {
24606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24607       };
24608     } catch (std::exception& e) {
24609       {
24610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24611       };
24612     } catch (Dali::DaliException e) {
24613       {
24614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24615       };
24616     } catch (...) {
24617       {
24618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24619       };
24620     }
24621   }
24622
24623   jresult = (void *)result;
24624   return jresult;
24625 }
24626
24627
24628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24629   unsigned int jresult ;
24630   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24631   Dali::PixelData arg2 ;
24632   Dali::PixelData *argp2 ;
24633   bool result;
24634
24635   arg1 = (Dali::Texture *)jarg1;
24636   argp2 = (Dali::PixelData *)jarg2;
24637   if (!argp2) {
24638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24639     return 0;
24640   }
24641   arg2 = *argp2;
24642   {
24643     try {
24644       result = (bool)(arg1)->Upload(arg2);
24645     } catch (std::out_of_range& e) {
24646       {
24647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24648       };
24649     } catch (std::exception& e) {
24650       {
24651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24652       };
24653     } catch (Dali::DaliException e) {
24654       {
24655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24656       };
24657     } catch (...) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24660       };
24661     }
24662   }
24663
24664   jresult = result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5, unsigned int jarg6, unsigned int jarg7, unsigned int jarg8) {
24670   unsigned int jresult ;
24671   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24672   Dali::PixelData arg2 ;
24673   unsigned int arg3 ;
24674   unsigned int arg4 ;
24675   unsigned int arg5 ;
24676   unsigned int arg6 ;
24677   unsigned int arg7 ;
24678   unsigned int arg8 ;
24679   Dali::PixelData *argp2 ;
24680   bool result;
24681
24682   arg1 = (Dali::Texture *)jarg1;
24683   argp2 = (Dali::PixelData *)jarg2;
24684   if (!argp2) {
24685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24686     return 0;
24687   }
24688   arg2 = *argp2;
24689   arg3 = (unsigned int)jarg3;
24690   arg4 = (unsigned int)jarg4;
24691   arg5 = (unsigned int)jarg5;
24692   arg6 = (unsigned int)jarg6;
24693   arg7 = (unsigned int)jarg7;
24694   arg8 = (unsigned int)jarg8;
24695   {
24696     try {
24697       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24698     } catch (std::out_of_range& e) {
24699       {
24700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24701       };
24702     } catch (std::exception& e) {
24703       {
24704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24705       };
24706     } catch (Dali::DaliException e) {
24707       {
24708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24709       };
24710     } catch (...) {
24711       {
24712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24713       };
24714     }
24715   }
24716
24717   jresult = result;
24718   return jresult;
24719 }
24720
24721
24722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24723   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24724
24725   arg1 = (Dali::Texture *)jarg1;
24726   {
24727     try {
24728       (arg1)->GenerateMipmaps();
24729     } catch (std::out_of_range& e) {
24730       {
24731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24732       };
24733     } catch (std::exception& e) {
24734       {
24735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24736       };
24737     } catch (Dali::DaliException e) {
24738       {
24739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24740       };
24741     } catch (...) {
24742       {
24743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24744       };
24745     }
24746   }
24747
24748 }
24749
24750
24751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24752   unsigned int jresult ;
24753   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24754   unsigned int result;
24755
24756   arg1 = (Dali::Texture *)jarg1;
24757   {
24758     try {
24759       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24760     } catch (std::out_of_range& e) {
24761       {
24762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24763       };
24764     } catch (std::exception& e) {
24765       {
24766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24767       };
24768     } catch (Dali::DaliException e) {
24769       {
24770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24771       };
24772     } catch (...) {
24773       {
24774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24775       };
24776     }
24777   }
24778
24779   jresult = result;
24780   return jresult;
24781 }
24782
24783
24784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24785   unsigned int jresult ;
24786   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24787   unsigned int result;
24788
24789   arg1 = (Dali::Texture *)jarg1;
24790   {
24791     try {
24792       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24793     } catch (std::out_of_range& e) {
24794       {
24795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24796       };
24797     } catch (std::exception& e) {
24798       {
24799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24800       };
24801     } catch (Dali::DaliException e) {
24802       {
24803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24804       };
24805     } catch (...) {
24806       {
24807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24808       };
24809     }
24810   }
24811
24812   jresult = result;
24813   return jresult;
24814 }
24815
24816
24817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24818   void * jresult ;
24819   Dali::Sampler result;
24820
24821   {
24822     try {
24823       result = Dali::Sampler::New();
24824     } catch (std::out_of_range& e) {
24825       {
24826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24827       };
24828     } catch (std::exception& e) {
24829       {
24830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24831       };
24832     } catch (Dali::DaliException e) {
24833       {
24834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24835       };
24836     } catch (...) {
24837       {
24838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24839       };
24840     }
24841   }
24842
24843   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24844   return jresult;
24845 }
24846
24847
24848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24849   void * jresult ;
24850   Dali::Sampler *result = 0 ;
24851
24852   {
24853     try {
24854       result = (Dali::Sampler *)new Dali::Sampler();
24855     } catch (std::out_of_range& e) {
24856       {
24857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24858       };
24859     } catch (std::exception& e) {
24860       {
24861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24862       };
24863     } catch (Dali::DaliException e) {
24864       {
24865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24866       };
24867     } catch (...) {
24868       {
24869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24870       };
24871     }
24872   }
24873
24874   jresult = (void *)result;
24875   return jresult;
24876 }
24877
24878
24879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24880   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24881
24882   arg1 = (Dali::Sampler *)jarg1;
24883   {
24884     try {
24885       delete arg1;
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24893       };
24894     } catch (Dali::DaliException e) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24897       };
24898     } catch (...) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24901       };
24902     }
24903   }
24904
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24909   void * jresult ;
24910   Dali::Sampler *arg1 = 0 ;
24911   Dali::Sampler *result = 0 ;
24912
24913   arg1 = (Dali::Sampler *)jarg1;
24914   if (!arg1) {
24915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24916     return 0;
24917   }
24918   {
24919     try {
24920       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24921     } catch (std::out_of_range& e) {
24922       {
24923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24924       };
24925     } catch (std::exception& e) {
24926       {
24927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (Dali::DaliException e) {
24930       {
24931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24932       };
24933     } catch (...) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24936       };
24937     }
24938   }
24939
24940   jresult = (void *)result;
24941   return jresult;
24942 }
24943
24944
24945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24946   void * jresult ;
24947   Dali::BaseHandle arg1 ;
24948   Dali::BaseHandle *argp1 ;
24949   Dali::Sampler result;
24950
24951   argp1 = (Dali::BaseHandle *)jarg1;
24952   if (!argp1) {
24953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24954     return 0;
24955   }
24956   arg1 = *argp1;
24957   {
24958     try {
24959       result = Dali::Sampler::DownCast(arg1);
24960     } catch (std::out_of_range& e) {
24961       {
24962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24963       };
24964     } catch (std::exception& e) {
24965       {
24966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24967       };
24968     } catch (Dali::DaliException e) {
24969       {
24970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24975       };
24976     }
24977   }
24978
24979   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24980   return jresult;
24981 }
24982
24983
24984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24985   void * jresult ;
24986   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24987   Dali::Sampler *arg2 = 0 ;
24988   Dali::Sampler *result = 0 ;
24989
24990   arg1 = (Dali::Sampler *)jarg1;
24991   arg2 = (Dali::Sampler *)jarg2;
24992   if (!arg2) {
24993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24994     return 0;
24995   }
24996   {
24997     try {
24998       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24999     } catch (std::out_of_range& e) {
25000       {
25001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25002       };
25003     } catch (std::exception& e) {
25004       {
25005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25006       };
25007     } catch (Dali::DaliException e) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25010       };
25011     } catch (...) {
25012       {
25013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25014       };
25015     }
25016   }
25017
25018   jresult = (void *)result;
25019   return jresult;
25020 }
25021
25022
25023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25024   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25025   Dali::FilterMode::Type arg2 ;
25026   Dali::FilterMode::Type arg3 ;
25027
25028   arg1 = (Dali::Sampler *)jarg1;
25029   arg2 = (Dali::FilterMode::Type)jarg2;
25030   arg3 = (Dali::FilterMode::Type)jarg3;
25031   {
25032     try {
25033       (arg1)->SetFilterMode(arg2,arg3);
25034     } catch (std::out_of_range& e) {
25035       {
25036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (std::exception& e) {
25039       {
25040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25041       };
25042     } catch (Dali::DaliException e) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25045       };
25046     } catch (...) {
25047       {
25048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25049       };
25050     }
25051   }
25052
25053 }
25054
25055
25056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25057   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25058   Dali::WrapMode::Type arg2 ;
25059   Dali::WrapMode::Type arg3 ;
25060
25061   arg1 = (Dali::Sampler *)jarg1;
25062   arg2 = (Dali::WrapMode::Type)jarg2;
25063   arg3 = (Dali::WrapMode::Type)jarg3;
25064   {
25065     try {
25066       (arg1)->SetWrapMode(arg2,arg3);
25067     } catch (std::out_of_range& e) {
25068       {
25069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25070       };
25071     } catch (std::exception& e) {
25072       {
25073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25074       };
25075     } catch (Dali::DaliException e) {
25076       {
25077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25078       };
25079     } catch (...) {
25080       {
25081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25082       };
25083     }
25084   }
25085
25086 }
25087
25088
25089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25090   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25091   Dali::WrapMode::Type arg2 ;
25092   Dali::WrapMode::Type arg3 ;
25093   Dali::WrapMode::Type arg4 ;
25094
25095   arg1 = (Dali::Sampler *)jarg1;
25096   arg2 = (Dali::WrapMode::Type)jarg2;
25097   arg3 = (Dali::WrapMode::Type)jarg3;
25098   arg4 = (Dali::WrapMode::Type)jarg4;
25099   {
25100     try {
25101       (arg1)->SetWrapMode(arg2,arg3,arg4);
25102     } catch (std::out_of_range& e) {
25103       {
25104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25105       };
25106     } catch (std::exception& e) {
25107       {
25108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25109       };
25110     } catch (Dali::DaliException e) {
25111       {
25112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25113       };
25114     } catch (...) {
25115       {
25116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25117       };
25118     }
25119   }
25120
25121 }
25122
25123
25124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25125   void * jresult ;
25126   Dali::TextureSet result;
25127
25128   {
25129     try {
25130       result = Dali::TextureSet::New();
25131     } catch (std::out_of_range& e) {
25132       {
25133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25134       };
25135     } catch (std::exception& e) {
25136       {
25137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25138       };
25139     } catch (Dali::DaliException e) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25142       };
25143     } catch (...) {
25144       {
25145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25146       };
25147     }
25148   }
25149
25150   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25151   return jresult;
25152 }
25153
25154
25155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25156   void * jresult ;
25157   Dali::TextureSet *result = 0 ;
25158
25159   {
25160     try {
25161       result = (Dali::TextureSet *)new Dali::TextureSet();
25162     } catch (std::out_of_range& e) {
25163       {
25164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (std::exception& e) {
25167       {
25168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25169       };
25170     } catch (Dali::DaliException e) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25173       };
25174     } catch (...) {
25175       {
25176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25177       };
25178     }
25179   }
25180
25181   jresult = (void *)result;
25182   return jresult;
25183 }
25184
25185
25186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25187   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25188
25189   arg1 = (Dali::TextureSet *)jarg1;
25190   {
25191     try {
25192       delete arg1;
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25200       };
25201     } catch (Dali::DaliException e) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25204       };
25205     } catch (...) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25208       };
25209     }
25210   }
25211
25212 }
25213
25214
25215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25216   void * jresult ;
25217   Dali::TextureSet *arg1 = 0 ;
25218   Dali::TextureSet *result = 0 ;
25219
25220   arg1 = (Dali::TextureSet *)jarg1;
25221   if (!arg1) {
25222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25223     return 0;
25224   }
25225   {
25226     try {
25227       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25228     } catch (std::out_of_range& e) {
25229       {
25230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25231       };
25232     } catch (std::exception& e) {
25233       {
25234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (Dali::DaliException e) {
25237       {
25238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25239       };
25240     } catch (...) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25243       };
25244     }
25245   }
25246
25247   jresult = (void *)result;
25248   return jresult;
25249 }
25250
25251
25252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25253   void * jresult ;
25254   Dali::BaseHandle arg1 ;
25255   Dali::BaseHandle *argp1 ;
25256   Dali::TextureSet result;
25257
25258   argp1 = (Dali::BaseHandle *)jarg1;
25259   if (!argp1) {
25260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25261     return 0;
25262   }
25263   arg1 = *argp1;
25264   {
25265     try {
25266       result = Dali::TextureSet::DownCast(arg1);
25267     } catch (std::out_of_range& e) {
25268       {
25269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (std::exception& e) {
25272       {
25273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25274       };
25275     } catch (Dali::DaliException e) {
25276       {
25277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25278       };
25279     } catch (...) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25282       };
25283     }
25284   }
25285
25286   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25292   void * jresult ;
25293   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25294   Dali::TextureSet *arg2 = 0 ;
25295   Dali::TextureSet *result = 0 ;
25296
25297   arg1 = (Dali::TextureSet *)jarg1;
25298   arg2 = (Dali::TextureSet *)jarg2;
25299   if (!arg2) {
25300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25301     return 0;
25302   }
25303   {
25304     try {
25305       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (Dali::DaliException e) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324
25325   jresult = (void *)result;
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25332   size_t arg2 ;
25333   Dali::Texture arg3 ;
25334   Dali::Texture *argp3 ;
25335
25336   arg1 = (Dali::TextureSet *)jarg1;
25337   arg2 = (size_t)jarg2;
25338   argp3 = (Dali::Texture *)jarg3;
25339   if (!argp3) {
25340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25341     return ;
25342   }
25343   arg3 = *argp3;
25344   {
25345     try {
25346       (arg1)->SetTexture(arg2,arg3);
25347     } catch (std::out_of_range& e) {
25348       {
25349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25350       };
25351     } catch (std::exception& e) {
25352       {
25353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (Dali::DaliException e) {
25356       {
25357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25358       };
25359     } catch (...) {
25360       {
25361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25362       };
25363     }
25364   }
25365
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25370   void * jresult ;
25371   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25372   size_t arg2 ;
25373   Dali::Texture result;
25374
25375   arg1 = (Dali::TextureSet *)jarg1;
25376   arg2 = (size_t)jarg2;
25377   {
25378     try {
25379       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25380     } catch (std::out_of_range& e) {
25381       {
25382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25383       };
25384     } catch (std::exception& e) {
25385       {
25386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25387       };
25388     } catch (Dali::DaliException e) {
25389       {
25390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25391       };
25392     } catch (...) {
25393       {
25394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25395       };
25396     }
25397   }
25398
25399   jresult = new Dali::Texture((const Dali::Texture &)result);
25400   return jresult;
25401 }
25402
25403
25404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25405   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25406   size_t arg2 ;
25407   Dali::Sampler arg3 ;
25408   Dali::Sampler *argp3 ;
25409
25410   arg1 = (Dali::TextureSet *)jarg1;
25411   arg2 = (size_t)jarg2;
25412   argp3 = (Dali::Sampler *)jarg3;
25413   if (!argp3) {
25414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25415     return ;
25416   }
25417   arg3 = *argp3;
25418   {
25419     try {
25420       (arg1)->SetSampler(arg2,arg3);
25421     } catch (std::out_of_range& e) {
25422       {
25423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25424       };
25425     } catch (std::exception& e) {
25426       {
25427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25428       };
25429     } catch (Dali::DaliException e) {
25430       {
25431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25432       };
25433     } catch (...) {
25434       {
25435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25436       };
25437     }
25438   }
25439
25440 }
25441
25442
25443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25444   void * jresult ;
25445   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25446   size_t arg2 ;
25447   Dali::Sampler result;
25448
25449   arg1 = (Dali::TextureSet *)jarg1;
25450   arg2 = (size_t)jarg2;
25451   {
25452     try {
25453       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25454     } catch (std::out_of_range& e) {
25455       {
25456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25457       };
25458     } catch (std::exception& e) {
25459       {
25460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25461       };
25462     } catch (Dali::DaliException e) {
25463       {
25464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25465       };
25466     } catch (...) {
25467       {
25468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25469       };
25470     }
25471   }
25472
25473   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25474   return jresult;
25475 }
25476
25477
25478 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25479   unsigned long jresult ;
25480   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25481   size_t result;
25482
25483   arg1 = (Dali::TextureSet *)jarg1;
25484   {
25485     try {
25486       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25487     } catch (std::out_of_range& e) {
25488       {
25489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (std::exception& e) {
25492       {
25493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25494       };
25495     } catch (Dali::DaliException e) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25498       };
25499     } catch (...) {
25500       {
25501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25502       };
25503     }
25504   }
25505
25506   jresult = (unsigned long)result;
25507   return jresult;
25508 }
25509
25510
25511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25512   void * jresult ;
25513   Dali::Property::Map *arg1 = 0 ;
25514   Dali::PropertyBuffer result;
25515
25516   arg1 = (Dali::Property::Map *)jarg1;
25517   if (!arg1) {
25518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25519     return 0;
25520   }
25521   {
25522     try {
25523       result = Dali::PropertyBuffer::New(*arg1);
25524     } catch (std::out_of_range& e) {
25525       {
25526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25527       };
25528     } catch (std::exception& e) {
25529       {
25530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25531       };
25532     } catch (Dali::DaliException e) {
25533       {
25534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25535       };
25536     } catch (...) {
25537       {
25538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25539       };
25540     }
25541   }
25542
25543   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25544   return jresult;
25545 }
25546
25547
25548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25549   void * jresult ;
25550   Dali::PropertyBuffer *result = 0 ;
25551
25552   {
25553     try {
25554       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25555     } catch (std::out_of_range& e) {
25556       {
25557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25558       };
25559     } catch (std::exception& e) {
25560       {
25561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25562       };
25563     } catch (Dali::DaliException e) {
25564       {
25565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25566       };
25567     } catch (...) {
25568       {
25569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25570       };
25571     }
25572   }
25573
25574   jresult = (void *)result;
25575   return jresult;
25576 }
25577
25578
25579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25580   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25581
25582   arg1 = (Dali::PropertyBuffer *)jarg1;
25583   {
25584     try {
25585       delete arg1;
25586     } catch (std::out_of_range& e) {
25587       {
25588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25589       };
25590     } catch (std::exception& e) {
25591       {
25592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25593       };
25594     } catch (Dali::DaliException e) {
25595       {
25596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25597       };
25598     } catch (...) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25601       };
25602     }
25603   }
25604
25605 }
25606
25607
25608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25609   void * jresult ;
25610   Dali::PropertyBuffer *arg1 = 0 ;
25611   Dali::PropertyBuffer *result = 0 ;
25612
25613   arg1 = (Dali::PropertyBuffer *)jarg1;
25614   if (!arg1) {
25615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25616     return 0;
25617   }
25618   {
25619     try {
25620       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25621     } catch (std::out_of_range& e) {
25622       {
25623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25624       };
25625     } catch (std::exception& e) {
25626       {
25627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25628       };
25629     } catch (Dali::DaliException e) {
25630       {
25631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25632       };
25633     } catch (...) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25636       };
25637     }
25638   }
25639
25640   jresult = (void *)result;
25641   return jresult;
25642 }
25643
25644
25645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25646   void * jresult ;
25647   Dali::BaseHandle arg1 ;
25648   Dali::BaseHandle *argp1 ;
25649   Dali::PropertyBuffer result;
25650
25651   argp1 = (Dali::BaseHandle *)jarg1;
25652   if (!argp1) {
25653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25654     return 0;
25655   }
25656   arg1 = *argp1;
25657   {
25658     try {
25659       result = Dali::PropertyBuffer::DownCast(arg1);
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25667       };
25668     } catch (Dali::DaliException e) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25671       };
25672     } catch (...) {
25673       {
25674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25675       };
25676     }
25677   }
25678
25679   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25680   return jresult;
25681 }
25682
25683
25684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25685   void * jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   Dali::PropertyBuffer *arg2 = 0 ;
25688   Dali::PropertyBuffer *result = 0 ;
25689
25690   arg1 = (Dali::PropertyBuffer *)jarg1;
25691   arg2 = (Dali::PropertyBuffer *)jarg2;
25692   if (!arg2) {
25693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25694     return 0;
25695   }
25696   {
25697     try {
25698       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25699     } catch (std::out_of_range& e) {
25700       {
25701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25702       };
25703     } catch (std::exception& e) {
25704       {
25705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25706       };
25707     } catch (Dali::DaliException e) {
25708       {
25709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25710       };
25711     } catch (...) {
25712       {
25713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25714       };
25715     }
25716   }
25717
25718   jresult = (void *)result;
25719   return jresult;
25720 }
25721
25722
25723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25724   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25725   void *arg2 = (void *) 0 ;
25726   std::size_t arg3 ;
25727
25728   arg1 = (Dali::PropertyBuffer *)jarg1;
25729   arg2 = jarg2;
25730   arg3 = (std::size_t)jarg3;
25731   {
25732     try {
25733       (arg1)->SetData((void const *)arg2,arg3);
25734     } catch (std::out_of_range& e) {
25735       {
25736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25737       };
25738     } catch (std::exception& e) {
25739       {
25740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25741       };
25742     } catch (Dali::DaliException e) {
25743       {
25744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25745       };
25746     } catch (...) {
25747       {
25748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25749       };
25750     }
25751   }
25752
25753 }
25754
25755
25756 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25757   unsigned long jresult ;
25758   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25759   std::size_t result;
25760
25761   arg1 = (Dali::PropertyBuffer *)jarg1;
25762   {
25763     try {
25764       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25765     } catch (std::out_of_range& e) {
25766       {
25767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25768       };
25769     } catch (std::exception& e) {
25770       {
25771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25772       };
25773     } catch (Dali::DaliException e) {
25774       {
25775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25776       };
25777     } catch (...) {
25778       {
25779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25780       };
25781     }
25782   }
25783
25784   jresult = (unsigned long)result;
25785   return jresult;
25786 }
25787
25788
25789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25790   void * jresult ;
25791   Dali::Geometry result;
25792
25793   {
25794     try {
25795       result = Dali::Geometry::New();
25796     } catch (std::out_of_range& e) {
25797       {
25798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25799       };
25800     } catch (std::exception& e) {
25801       {
25802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25803       };
25804     } catch (Dali::DaliException e) {
25805       {
25806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25807       };
25808     } catch (...) {
25809       {
25810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25811       };
25812     }
25813   }
25814
25815   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25816   return jresult;
25817 }
25818
25819
25820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25821   void * jresult ;
25822   Dali::Geometry *result = 0 ;
25823
25824   {
25825     try {
25826       result = (Dali::Geometry *)new Dali::Geometry();
25827     } catch (std::out_of_range& e) {
25828       {
25829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25830       };
25831     } catch (std::exception& e) {
25832       {
25833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25834       };
25835     } catch (Dali::DaliException e) {
25836       {
25837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25838       };
25839     } catch (...) {
25840       {
25841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25842       };
25843     }
25844   }
25845
25846   jresult = (void *)result;
25847   return jresult;
25848 }
25849
25850
25851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25852   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25853
25854   arg1 = (Dali::Geometry *)jarg1;
25855   {
25856     try {
25857       delete arg1;
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25865       };
25866     } catch (Dali::DaliException e) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25869       };
25870     } catch (...) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25873       };
25874     }
25875   }
25876
25877 }
25878
25879
25880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25881   void * jresult ;
25882   Dali::Geometry *arg1 = 0 ;
25883   Dali::Geometry *result = 0 ;
25884
25885   arg1 = (Dali::Geometry *)jarg1;
25886   if (!arg1) {
25887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25888     return 0;
25889   }
25890   {
25891     try {
25892       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25893     } catch (std::out_of_range& e) {
25894       {
25895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25896       };
25897     } catch (std::exception& e) {
25898       {
25899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (Dali::DaliException e) {
25902       {
25903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25904       };
25905     } catch (...) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25908       };
25909     }
25910   }
25911
25912   jresult = (void *)result;
25913   return jresult;
25914 }
25915
25916
25917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25918   void * jresult ;
25919   Dali::BaseHandle arg1 ;
25920   Dali::BaseHandle *argp1 ;
25921   Dali::Geometry result;
25922
25923   argp1 = (Dali::BaseHandle *)jarg1;
25924   if (!argp1) {
25925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25926     return 0;
25927   }
25928   arg1 = *argp1;
25929   {
25930     try {
25931       result = Dali::Geometry::DownCast(arg1);
25932     } catch (std::out_of_range& e) {
25933       {
25934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25935       };
25936     } catch (std::exception& e) {
25937       {
25938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (Dali::DaliException e) {
25941       {
25942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25943       };
25944     } catch (...) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25947       };
25948     }
25949   }
25950
25951   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25952   return jresult;
25953 }
25954
25955
25956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25957   void * jresult ;
25958   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25959   Dali::Geometry *arg2 = 0 ;
25960   Dali::Geometry *result = 0 ;
25961
25962   arg1 = (Dali::Geometry *)jarg1;
25963   arg2 = (Dali::Geometry *)jarg2;
25964   if (!arg2) {
25965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25966     return 0;
25967   }
25968   {
25969     try {
25970       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (void *)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25996   unsigned long jresult ;
25997   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25998   Dali::PropertyBuffer *arg2 = 0 ;
25999   std::size_t result;
26000
26001   arg1 = (Dali::Geometry *)jarg1;
26002   arg2 = (Dali::PropertyBuffer *)jarg2;
26003   if (!arg2) {
26004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
26005     return 0;
26006   }
26007   {
26008     try {
26009       result = (arg1)->AddVertexBuffer(*arg2);
26010     } catch (std::out_of_range& e) {
26011       {
26012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26013       };
26014     } catch (std::exception& e) {
26015       {
26016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26017       };
26018     } catch (Dali::DaliException e) {
26019       {
26020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26021       };
26022     } catch (...) {
26023       {
26024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26025       };
26026     }
26027   }
26028
26029   jresult = (unsigned long)result;
26030   return jresult;
26031 }
26032
26033
26034 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26035   unsigned long jresult ;
26036   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26037   std::size_t result;
26038
26039   arg1 = (Dali::Geometry *)jarg1;
26040   {
26041     try {
26042       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26043     } catch (std::out_of_range& e) {
26044       {
26045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26046       };
26047     } catch (std::exception& e) {
26048       {
26049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26050       };
26051     } catch (Dali::DaliException e) {
26052       {
26053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26054       };
26055     } catch (...) {
26056       {
26057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26058       };
26059     }
26060   }
26061
26062   jresult = (unsigned long)result;
26063   return jresult;
26064 }
26065
26066
26067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26068   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26069   std::size_t arg2 ;
26070
26071   arg1 = (Dali::Geometry *)jarg1;
26072   arg2 = (std::size_t)jarg2;
26073   {
26074     try {
26075       (arg1)->RemoveVertexBuffer(arg2);
26076     } catch (std::out_of_range& e) {
26077       {
26078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26079       };
26080     } catch (std::exception& e) {
26081       {
26082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26083       };
26084     } catch (Dali::DaliException e) {
26085       {
26086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26087       };
26088     } catch (...) {
26089       {
26090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26091       };
26092     }
26093   }
26094
26095 }
26096
26097
26098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26099   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26100   unsigned short *arg2 = (unsigned short *) 0 ;
26101   size_t arg3 ;
26102
26103   arg1 = (Dali::Geometry *)jarg1;
26104   arg2 = jarg2;
26105   arg3 = (size_t)jarg3;
26106   {
26107     try {
26108       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26109     } catch (std::out_of_range& e) {
26110       {
26111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26112       };
26113     } catch (std::exception& e) {
26114       {
26115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26116       };
26117     } catch (Dali::DaliException e) {
26118       {
26119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26124       };
26125     }
26126   }
26127
26128
26129
26130 }
26131
26132
26133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26134   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26135   Dali::Geometry::Type arg2 ;
26136
26137   arg1 = (Dali::Geometry *)jarg1;
26138   arg2 = (Dali::Geometry::Type)jarg2;
26139   {
26140     try {
26141       (arg1)->SetType(arg2);
26142     } catch (std::out_of_range& e) {
26143       {
26144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26145       };
26146     } catch (std::exception& e) {
26147       {
26148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26149       };
26150     } catch (Dali::DaliException e) {
26151       {
26152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26153       };
26154     } catch (...) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26157       };
26158     }
26159   }
26160
26161 }
26162
26163
26164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26165   int jresult ;
26166   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26167   Dali::Geometry::Type result;
26168
26169   arg1 = (Dali::Geometry *)jarg1;
26170   {
26171     try {
26172       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26173     } catch (std::out_of_range& e) {
26174       {
26175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26176       };
26177     } catch (std::exception& e) {
26178       {
26179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26180       };
26181     } catch (Dali::DaliException e) {
26182       {
26183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26184       };
26185     } catch (...) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26188       };
26189     }
26190   }
26191
26192   jresult = (int)result;
26193   return jresult;
26194 }
26195
26196
26197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26198   void * jresult ;
26199   Dali::Shader::Hint *result = 0 ;
26200
26201   {
26202     try {
26203       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26204     } catch (std::out_of_range& e) {
26205       {
26206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (std::exception& e) {
26209       {
26210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26211       };
26212     } catch (Dali::DaliException e) {
26213       {
26214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26215       };
26216     } catch (...) {
26217       {
26218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26219       };
26220     }
26221   }
26222
26223   jresult = (void *)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26229   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26230
26231   arg1 = (Dali::Shader::Hint *)jarg1;
26232   {
26233     try {
26234       delete arg1;
26235     } catch (std::out_of_range& e) {
26236       {
26237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26238       };
26239     } catch (std::exception& e) {
26240       {
26241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26242       };
26243     } catch (Dali::DaliException e) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26246       };
26247     } catch (...) {
26248       {
26249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26250       };
26251     }
26252   }
26253
26254 }
26255
26256
26257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26258   int jresult ;
26259   int result;
26260
26261   result = (int)Dali::Shader::Property::PROGRAM;
26262   jresult = (int)result;
26263   return jresult;
26264 }
26265
26266
26267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26268   void * jresult ;
26269   Dali::Shader::Property *result = 0 ;
26270
26271   {
26272     try {
26273       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (Dali::DaliException e) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26285       };
26286     } catch (...) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26289       };
26290     }
26291   }
26292
26293   jresult = (void *)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26299   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26300
26301   arg1 = (Dali::Shader::Property *)jarg1;
26302   {
26303     try {
26304       delete arg1;
26305     } catch (std::out_of_range& e) {
26306       {
26307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26308       };
26309     } catch (std::exception& e) {
26310       {
26311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26312       };
26313     } catch (Dali::DaliException e) {
26314       {
26315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26316       };
26317     } catch (...) {
26318       {
26319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26320       };
26321     }
26322   }
26323
26324 }
26325
26326
26327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26328   void * jresult ;
26329   std::string *arg1 = 0 ;
26330   std::string *arg2 = 0 ;
26331   Dali::Shader::Hint::Value arg3 ;
26332   Dali::Shader result;
26333
26334   if (!jarg1) {
26335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26336     return 0;
26337   }
26338   std::string arg1_str(jarg1);
26339   arg1 = &arg1_str;
26340   if (!jarg2) {
26341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26342     return 0;
26343   }
26344   std::string arg2_str(jarg2);
26345   arg2 = &arg2_str;
26346   arg3 = (Dali::Shader::Hint::Value)jarg3;
26347   {
26348     try {
26349       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26350     } catch (std::out_of_range& e) {
26351       {
26352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26353       };
26354     } catch (std::exception& e) {
26355       {
26356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26357       };
26358     } catch (Dali::DaliException e) {
26359       {
26360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26361       };
26362     } catch (...) {
26363       {
26364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26365       };
26366     }
26367   }
26368
26369   jresult = new Dali::Shader((const Dali::Shader &)result);
26370
26371   //argout typemap for const std::string&
26372
26373
26374   //argout typemap for const std::string&
26375
26376   return jresult;
26377 }
26378
26379
26380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26381   void * jresult ;
26382   std::string *arg1 = 0 ;
26383   std::string *arg2 = 0 ;
26384   Dali::Shader result;
26385
26386   if (!jarg1) {
26387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26388     return 0;
26389   }
26390   std::string arg1_str(jarg1);
26391   arg1 = &arg1_str;
26392   if (!jarg2) {
26393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26394     return 0;
26395   }
26396   std::string arg2_str(jarg2);
26397   arg2 = &arg2_str;
26398   {
26399     try {
26400       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26401     } catch (std::out_of_range& e) {
26402       {
26403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26404       };
26405     } catch (std::exception& e) {
26406       {
26407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26408       };
26409     } catch (Dali::DaliException e) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26412       };
26413     } catch (...) {
26414       {
26415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26416       };
26417     }
26418   }
26419
26420   jresult = new Dali::Shader((const Dali::Shader &)result);
26421
26422   //argout typemap for const std::string&
26423
26424
26425   //argout typemap for const std::string&
26426
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26432   void * jresult ;
26433   Dali::Shader *result = 0 ;
26434
26435   {
26436     try {
26437       result = (Dali::Shader *)new Dali::Shader();
26438     } catch (std::out_of_range& e) {
26439       {
26440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26441       };
26442     } catch (std::exception& e) {
26443       {
26444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26445       };
26446     } catch (Dali::DaliException e) {
26447       {
26448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26449       };
26450     } catch (...) {
26451       {
26452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26453       };
26454     }
26455   }
26456
26457   jresult = (void *)result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26463   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26464
26465   arg1 = (Dali::Shader *)jarg1;
26466   {
26467     try {
26468       delete arg1;
26469     } catch (std::out_of_range& e) {
26470       {
26471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26472       };
26473     } catch (std::exception& e) {
26474       {
26475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26476       };
26477     } catch (Dali::DaliException e) {
26478       {
26479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26484       };
26485     }
26486   }
26487
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26492   void * jresult ;
26493   Dali::Shader *arg1 = 0 ;
26494   Dali::Shader *result = 0 ;
26495
26496   arg1 = (Dali::Shader *)jarg1;
26497   if (!arg1) {
26498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26499     return 0;
26500   }
26501   {
26502     try {
26503       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26504     } catch (std::out_of_range& e) {
26505       {
26506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26507       };
26508     } catch (std::exception& e) {
26509       {
26510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26511       };
26512     } catch (Dali::DaliException e) {
26513       {
26514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26515       };
26516     } catch (...) {
26517       {
26518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26519       };
26520     }
26521   }
26522
26523   jresult = (void *)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26529   void * jresult ;
26530   Dali::BaseHandle arg1 ;
26531   Dali::BaseHandle *argp1 ;
26532   Dali::Shader result;
26533
26534   argp1 = (Dali::BaseHandle *)jarg1;
26535   if (!argp1) {
26536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26537     return 0;
26538   }
26539   arg1 = *argp1;
26540   {
26541     try {
26542       result = Dali::Shader::DownCast(arg1);
26543     } catch (std::out_of_range& e) {
26544       {
26545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26546       };
26547     } catch (std::exception& e) {
26548       {
26549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26550       };
26551     } catch (Dali::DaliException e) {
26552       {
26553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26554       };
26555     } catch (...) {
26556       {
26557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26558       };
26559     }
26560   }
26561
26562   jresult = new Dali::Shader((const Dali::Shader &)result);
26563   return jresult;
26564 }
26565
26566
26567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26568   void * jresult ;
26569   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26570   Dali::Shader *arg2 = 0 ;
26571   Dali::Shader *result = 0 ;
26572
26573   arg1 = (Dali::Shader *)jarg1;
26574   arg2 = (Dali::Shader *)jarg2;
26575   if (!arg2) {
26576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26577     return 0;
26578   }
26579   {
26580     try {
26581       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26582     } catch (std::out_of_range& e) {
26583       {
26584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26585       };
26586     } catch (std::exception& e) {
26587       {
26588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26589       };
26590     } catch (Dali::DaliException e) {
26591       {
26592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26593       };
26594     } catch (...) {
26595       {
26596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26597       };
26598     }
26599   }
26600
26601   jresult = (void *)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26607   int jresult ;
26608   int result;
26609
26610   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26611   jresult = (int)result;
26612   return jresult;
26613 }
26614
26615
26616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26617   int jresult ;
26618   int result;
26619
26620   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26621   jresult = (int)result;
26622   return jresult;
26623 }
26624
26625
26626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26627   int jresult ;
26628   int result;
26629
26630   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26631   jresult = (int)result;
26632   return jresult;
26633 }
26634
26635
26636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26637   int jresult ;
26638   int result;
26639
26640   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26641   jresult = (int)result;
26642   return jresult;
26643 }
26644
26645
26646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26647   int jresult ;
26648   int result;
26649
26650   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26651   jresult = (int)result;
26652   return jresult;
26653 }
26654
26655
26656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26657   int jresult ;
26658   int result;
26659
26660   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26661   jresult = (int)result;
26662   return jresult;
26663 }
26664
26665
26666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26667   int jresult ;
26668   int result;
26669
26670   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26671   jresult = (int)result;
26672   return jresult;
26673 }
26674
26675
26676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26677   int jresult ;
26678   int result;
26679
26680   result = (int)Dali::Renderer::Property::BLEND_MODE;
26681   jresult = (int)result;
26682   return jresult;
26683 }
26684
26685
26686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26687   int jresult ;
26688   int result;
26689
26690   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26691   jresult = (int)result;
26692   return jresult;
26693 }
26694
26695
26696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26697   int jresult ;
26698   int result;
26699
26700   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26701   jresult = (int)result;
26702   return jresult;
26703 }
26704
26705
26706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26707   int jresult ;
26708   int result;
26709
26710   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26711   jresult = (int)result;
26712   return jresult;
26713 }
26714
26715
26716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26717   int jresult ;
26718   int result;
26719
26720   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26721   jresult = (int)result;
26722   return jresult;
26723 }
26724
26725
26726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26727   int jresult ;
26728   int result;
26729
26730   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26731   jresult = (int)result;
26732   return jresult;
26733 }
26734
26735
26736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26737   int jresult ;
26738   int result;
26739
26740   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26741   jresult = (int)result;
26742   return jresult;
26743 }
26744
26745
26746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26747   int jresult ;
26748   int result;
26749
26750   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26751   jresult = (int)result;
26752   return jresult;
26753 }
26754
26755
26756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26757   int jresult ;
26758   int result;
26759
26760   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26761   jresult = (int)result;
26762   return jresult;
26763 }
26764
26765
26766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26767   int jresult ;
26768   int result;
26769
26770   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26771   jresult = (int)result;
26772   return jresult;
26773 }
26774
26775
26776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26777   int jresult ;
26778   int result;
26779
26780   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26781   jresult = (int)result;
26782   return jresult;
26783 }
26784
26785
26786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26787   int jresult ;
26788   int result;
26789
26790   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26791   jresult = (int)result;
26792   return jresult;
26793 }
26794
26795
26796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26797   int jresult ;
26798   int result;
26799
26800   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26801   jresult = (int)result;
26802   return jresult;
26803 }
26804
26805
26806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26807   int jresult ;
26808   int result;
26809
26810   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26811   jresult = (int)result;
26812   return jresult;
26813 }
26814
26815
26816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26817   int jresult ;
26818   int result;
26819
26820   result = (int)Dali::Renderer::Property::RENDER_MODE;
26821   jresult = (int)result;
26822   return jresult;
26823 }
26824
26825
26826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26827   int jresult ;
26828   int result;
26829
26830   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26831   jresult = (int)result;
26832   return jresult;
26833 }
26834
26835
26836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26837   int jresult ;
26838   int result;
26839
26840   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26841   jresult = (int)result;
26842   return jresult;
26843 }
26844
26845
26846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26847   int jresult ;
26848   int result;
26849
26850   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26851   jresult = (int)result;
26852   return jresult;
26853 }
26854
26855
26856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26857   int jresult ;
26858   int result;
26859
26860   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26861   jresult = (int)result;
26862   return jresult;
26863 }
26864
26865
26866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26867   int jresult ;
26868   int result;
26869
26870   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26871   jresult = (int)result;
26872   return jresult;
26873 }
26874
26875
26876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26877   int jresult ;
26878   int result;
26879
26880   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26881   jresult = (int)result;
26882   return jresult;
26883 }
26884
26885
26886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26887   int jresult ;
26888   int result;
26889
26890   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26891   jresult = (int)result;
26892   return jresult;
26893 }
26894
26895
26896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26897   void * jresult ;
26898   Dali::Renderer::Property *result = 0 ;
26899
26900   {
26901     try {
26902       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26903     } catch (std::out_of_range& e) {
26904       {
26905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (std::exception& e) {
26908       {
26909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26910       };
26911     } catch (Dali::DaliException e) {
26912       {
26913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26914       };
26915     } catch (...) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26918       };
26919     }
26920   }
26921
26922   jresult = (void *)result;
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26928   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26929
26930   arg1 = (Dali::Renderer::Property *)jarg1;
26931   {
26932     try {
26933       delete arg1;
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26949       };
26950     }
26951   }
26952
26953 }
26954
26955
26956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26957   void * jresult ;
26958   Dali::Geometry *arg1 = 0 ;
26959   Dali::Shader *arg2 = 0 ;
26960   Dali::Renderer result;
26961
26962   arg1 = (Dali::Geometry *)jarg1;
26963   if (!arg1) {
26964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26965     return 0;
26966   }
26967   arg2 = (Dali::Shader *)jarg2;
26968   if (!arg2) {
26969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26970     return 0;
26971   }
26972   {
26973     try {
26974       result = Dali::Renderer::New(*arg1,*arg2);
26975     } catch (std::out_of_range& e) {
26976       {
26977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26978       };
26979     } catch (std::exception& e) {
26980       {
26981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26982       };
26983     } catch (Dali::DaliException e) {
26984       {
26985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26986       };
26987     } catch (...) {
26988       {
26989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26990       };
26991     }
26992   }
26993
26994   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
27000   void * jresult ;
27001   Dali::Renderer *result = 0 ;
27002
27003   {
27004     try {
27005       result = (Dali::Renderer *)new Dali::Renderer();
27006     } catch (std::out_of_range& e) {
27007       {
27008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27009       };
27010     } catch (std::exception& e) {
27011       {
27012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27013       };
27014     } catch (Dali::DaliException e) {
27015       {
27016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27017       };
27018     } catch (...) {
27019       {
27020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27021       };
27022     }
27023   }
27024
27025   jresult = (void *)result;
27026   return jresult;
27027 }
27028
27029
27030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
27031   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27032
27033   arg1 = (Dali::Renderer *)jarg1;
27034   {
27035     try {
27036       delete arg1;
27037     } catch (std::out_of_range& e) {
27038       {
27039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27040       };
27041     } catch (std::exception& e) {
27042       {
27043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27044       };
27045     } catch (Dali::DaliException e) {
27046       {
27047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27048       };
27049     } catch (...) {
27050       {
27051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27052       };
27053     }
27054   }
27055
27056 }
27057
27058
27059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
27060   void * jresult ;
27061   Dali::Renderer *arg1 = 0 ;
27062   Dali::Renderer *result = 0 ;
27063
27064   arg1 = (Dali::Renderer *)jarg1;
27065   if (!arg1) {
27066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27067     return 0;
27068   }
27069   {
27070     try {
27071       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27072     } catch (std::out_of_range& e) {
27073       {
27074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27075       };
27076     } catch (std::exception& e) {
27077       {
27078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27079       };
27080     } catch (Dali::DaliException e) {
27081       {
27082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27083       };
27084     } catch (...) {
27085       {
27086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27087       };
27088     }
27089   }
27090
27091   jresult = (void *)result;
27092   return jresult;
27093 }
27094
27095
27096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27097   void * jresult ;
27098   Dali::BaseHandle arg1 ;
27099   Dali::BaseHandle *argp1 ;
27100   Dali::Renderer result;
27101
27102   argp1 = (Dali::BaseHandle *)jarg1;
27103   if (!argp1) {
27104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27105     return 0;
27106   }
27107   arg1 = *argp1;
27108   {
27109     try {
27110       result = Dali::Renderer::DownCast(arg1);
27111     } catch (std::out_of_range& e) {
27112       {
27113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27114       };
27115     } catch (std::exception& e) {
27116       {
27117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27118       };
27119     } catch (Dali::DaliException e) {
27120       {
27121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27122       };
27123     } catch (...) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27126       };
27127     }
27128   }
27129
27130   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27131   return jresult;
27132 }
27133
27134
27135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27136   void * jresult ;
27137   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27138   Dali::Renderer *arg2 = 0 ;
27139   Dali::Renderer *result = 0 ;
27140
27141   arg1 = (Dali::Renderer *)jarg1;
27142   arg2 = (Dali::Renderer *)jarg2;
27143   if (!arg2) {
27144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27145     return 0;
27146   }
27147   {
27148     try {
27149       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27150     } catch (std::out_of_range& e) {
27151       {
27152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (std::exception& e) {
27155       {
27156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27157       };
27158     } catch (Dali::DaliException e) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27161       };
27162     } catch (...) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27165       };
27166     }
27167   }
27168
27169   jresult = (void *)result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27175   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27176   Dali::Geometry *arg2 = 0 ;
27177
27178   arg1 = (Dali::Renderer *)jarg1;
27179   arg2 = (Dali::Geometry *)jarg2;
27180   if (!arg2) {
27181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27182     return ;
27183   }
27184   {
27185     try {
27186       (arg1)->SetGeometry(*arg2);
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27202       };
27203     }
27204   }
27205
27206 }
27207
27208
27209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27210   void * jresult ;
27211   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27212   Dali::Geometry result;
27213
27214   arg1 = (Dali::Renderer *)jarg1;
27215   {
27216     try {
27217       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27225       };
27226     } catch (Dali::DaliException e) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27229       };
27230     } catch (...) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27233       };
27234     }
27235   }
27236
27237   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27238   return jresult;
27239 }
27240
27241
27242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27243   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27244   int arg2 ;
27245   int arg3 ;
27246
27247   arg1 = (Dali::Renderer *)jarg1;
27248   arg2 = (int)jarg2;
27249   arg3 = (int)jarg3;
27250   {
27251     try {
27252       (arg1)->SetIndexRange(arg2,arg3);
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27268       };
27269     }
27270   }
27271
27272 }
27273
27274
27275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27276   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27277   Dali::TextureSet *arg2 = 0 ;
27278
27279   arg1 = (Dali::Renderer *)jarg1;
27280   arg2 = (Dali::TextureSet *)jarg2;
27281   if (!arg2) {
27282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27283     return ;
27284   }
27285   {
27286     try {
27287       (arg1)->SetTextures(*arg2);
27288     } catch (std::out_of_range& e) {
27289       {
27290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (std::exception& e) {
27293       {
27294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27295       };
27296     } catch (Dali::DaliException e) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27299       };
27300     } catch (...) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27303       };
27304     }
27305   }
27306
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27311   void * jresult ;
27312   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27313   Dali::TextureSet result;
27314
27315   arg1 = (Dali::Renderer *)jarg1;
27316   {
27317     try {
27318       result = ((Dali::Renderer const *)arg1)->GetTextures();
27319     } catch (std::out_of_range& e) {
27320       {
27321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (std::exception& e) {
27324       {
27325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27326       };
27327     } catch (Dali::DaliException e) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27330       };
27331     } catch (...) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27334       };
27335     }
27336   }
27337
27338   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27339   return jresult;
27340 }
27341
27342
27343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27344   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27345   Dali::Shader *arg2 = 0 ;
27346
27347   arg1 = (Dali::Renderer *)jarg1;
27348   arg2 = (Dali::Shader *)jarg2;
27349   if (!arg2) {
27350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27351     return ;
27352   }
27353   {
27354     try {
27355       (arg1)->SetShader(*arg2);
27356     } catch (std::out_of_range& e) {
27357       {
27358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27359       };
27360     } catch (std::exception& e) {
27361       {
27362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27363       };
27364     } catch (Dali::DaliException e) {
27365       {
27366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27367       };
27368     } catch (...) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27371       };
27372     }
27373   }
27374
27375 }
27376
27377
27378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27379   void * jresult ;
27380   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27381   Dali::Shader result;
27382
27383   arg1 = (Dali::Renderer *)jarg1;
27384   {
27385     try {
27386       result = ((Dali::Renderer const *)arg1)->GetShader();
27387     } catch (std::out_of_range& e) {
27388       {
27389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27390       };
27391     } catch (std::exception& e) {
27392       {
27393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27394       };
27395     } catch (Dali::DaliException e) {
27396       {
27397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27398       };
27399     } catch (...) {
27400       {
27401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27402       };
27403     }
27404   }
27405
27406   jresult = new Dali::Shader((const Dali::Shader &)result);
27407   return jresult;
27408 }
27409
27410
27411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27412   void * jresult ;
27413   Dali::FrameBuffer::Attachment *result = 0 ;
27414
27415   {
27416     try {
27417       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27418     } catch (std::out_of_range& e) {
27419       {
27420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27421       };
27422     } catch (std::exception& e) {
27423       {
27424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27425       };
27426     } catch (Dali::DaliException e) {
27427       {
27428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27429       };
27430     } catch (...) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27433       };
27434     }
27435   }
27436
27437   jresult = (void *)result;
27438   return jresult;
27439 }
27440
27441
27442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27443   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27444
27445   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27446   {
27447     try {
27448       delete arg1;
27449     } catch (std::out_of_range& e) {
27450       {
27451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27452       };
27453     } catch (std::exception& e) {
27454       {
27455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27456       };
27457     } catch (Dali::DaliException e) {
27458       {
27459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27460       };
27461     } catch (...) {
27462       {
27463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27464       };
27465     }
27466   }
27467
27468 }
27469
27470
27471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27472   void * jresult ;
27473   unsigned int arg1 ;
27474   unsigned int arg2 ;
27475   unsigned int arg3 ;
27476   Dali::FrameBuffer result;
27477
27478   arg1 = (unsigned int)jarg1;
27479   arg2 = (unsigned int)jarg2;
27480   arg3 = (unsigned int)jarg3;
27481   {
27482     try {
27483       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27484     } catch (std::out_of_range& e) {
27485       {
27486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27487       };
27488     } catch (std::exception& e) {
27489       {
27490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27491       };
27492     } catch (Dali::DaliException e) {
27493       {
27494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27495       };
27496     } catch (...) {
27497       {
27498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27499       };
27500     }
27501   }
27502
27503   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27504   return jresult;
27505 }
27506
27507
27508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27509   void * jresult ;
27510   Dali::FrameBuffer *result = 0 ;
27511
27512   {
27513     try {
27514       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27515     } catch (std::out_of_range& e) {
27516       {
27517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27518       };
27519     } catch (std::exception& e) {
27520       {
27521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27522       };
27523     } catch (Dali::DaliException e) {
27524       {
27525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27526       };
27527     } catch (...) {
27528       {
27529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27530       };
27531     }
27532   }
27533
27534   jresult = (void *)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27540   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27541
27542   arg1 = (Dali::FrameBuffer *)jarg1;
27543   {
27544     try {
27545       delete arg1;
27546     } catch (std::out_of_range& e) {
27547       {
27548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27549       };
27550     } catch (std::exception& e) {
27551       {
27552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27553       };
27554     } catch (Dali::DaliException e) {
27555       {
27556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27557       };
27558     } catch (...) {
27559       {
27560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27561       };
27562     }
27563   }
27564
27565 }
27566
27567
27568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27569   void * jresult ;
27570   Dali::FrameBuffer *arg1 = 0 ;
27571   Dali::FrameBuffer *result = 0 ;
27572
27573   arg1 = (Dali::FrameBuffer *)jarg1;
27574   if (!arg1) {
27575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27576     return 0;
27577   }
27578   {
27579     try {
27580       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27581     } catch (std::out_of_range& e) {
27582       {
27583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27584       };
27585     } catch (std::exception& e) {
27586       {
27587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27588       };
27589     } catch (Dali::DaliException e) {
27590       {
27591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27592       };
27593     } catch (...) {
27594       {
27595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27596       };
27597     }
27598   }
27599
27600   jresult = (void *)result;
27601   return jresult;
27602 }
27603
27604
27605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27606   void * jresult ;
27607   Dali::BaseHandle arg1 ;
27608   Dali::BaseHandle *argp1 ;
27609   Dali::FrameBuffer result;
27610
27611   argp1 = (Dali::BaseHandle *)jarg1;
27612   if (!argp1) {
27613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27614     return 0;
27615   }
27616   arg1 = *argp1;
27617   {
27618     try {
27619       result = Dali::FrameBuffer::DownCast(arg1);
27620     } catch (std::out_of_range& e) {
27621       {
27622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27623       };
27624     } catch (std::exception& e) {
27625       {
27626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27627       };
27628     } catch (Dali::DaliException e) {
27629       {
27630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27631       };
27632     } catch (...) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27635       };
27636     }
27637   }
27638
27639   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27640   return jresult;
27641 }
27642
27643
27644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27645   void * jresult ;
27646   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27647   Dali::FrameBuffer *arg2 = 0 ;
27648   Dali::FrameBuffer *result = 0 ;
27649
27650   arg1 = (Dali::FrameBuffer *)jarg1;
27651   arg2 = (Dali::FrameBuffer *)jarg2;
27652   if (!arg2) {
27653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27654     return 0;
27655   }
27656   {
27657     try {
27658       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27659     } catch (std::out_of_range& e) {
27660       {
27661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27662       };
27663     } catch (std::exception& e) {
27664       {
27665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27666       };
27667     } catch (Dali::DaliException e) {
27668       {
27669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27670       };
27671     } catch (...) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27674       };
27675     }
27676   }
27677
27678   jresult = (void *)result;
27679   return jresult;
27680 }
27681
27682
27683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27684   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27685   Dali::Texture *arg2 = 0 ;
27686
27687   arg1 = (Dali::FrameBuffer *)jarg1;
27688   arg2 = (Dali::Texture *)jarg2;
27689   if (!arg2) {
27690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27691     return ;
27692   }
27693   {
27694     try {
27695       (arg1)->AttachColorTexture(*arg2);
27696     } catch (std::out_of_range& e) {
27697       {
27698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27699       };
27700     } catch (std::exception& e) {
27701       {
27702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27703       };
27704     } catch (Dali::DaliException e) {
27705       {
27706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27707       };
27708     } catch (...) {
27709       {
27710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27711       };
27712     }
27713   }
27714
27715 }
27716
27717
27718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27719   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27720   Dali::Texture *arg2 = 0 ;
27721   unsigned int arg3 ;
27722   unsigned int arg4 ;
27723
27724   arg1 = (Dali::FrameBuffer *)jarg1;
27725   arg2 = (Dali::Texture *)jarg2;
27726   if (!arg2) {
27727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27728     return ;
27729   }
27730   arg3 = (unsigned int)jarg3;
27731   arg4 = (unsigned int)jarg4;
27732   {
27733     try {
27734       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27735     } catch (std::out_of_range& e) {
27736       {
27737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27738       };
27739     } catch (std::exception& e) {
27740       {
27741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27742       };
27743     } catch (Dali::DaliException e) {
27744       {
27745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27746       };
27747     } catch (...) {
27748       {
27749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27750       };
27751     }
27752   }
27753
27754 }
27755
27756
27757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27758   void * jresult ;
27759   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27760   Dali::Texture result;
27761
27762   arg1 = (Dali::FrameBuffer *)jarg1;
27763   {
27764     try {
27765       result = (arg1)->GetColorTexture();
27766     } catch (std::out_of_range& e) {
27767       {
27768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27769       };
27770     } catch (std::exception& e) {
27771       {
27772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27773       };
27774     } catch (Dali::DaliException e) {
27775       {
27776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27777       };
27778     } catch (...) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27781       };
27782     }
27783   }
27784
27785   jresult = new Dali::Texture((const Dali::Texture &)result);
27786   return jresult;
27787 }
27788
27789
27790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27791   void * jresult ;
27792   Dali::RenderTaskList *result = 0 ;
27793
27794   {
27795     try {
27796       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27797     } catch (std::out_of_range& e) {
27798       {
27799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27800       };
27801     } catch (std::exception& e) {
27802       {
27803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27804       };
27805     } catch (Dali::DaliException e) {
27806       {
27807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27808       };
27809     } catch (...) {
27810       {
27811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27812       };
27813     }
27814   }
27815
27816   jresult = (void *)result;
27817   return jresult;
27818 }
27819
27820
27821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27822   void * jresult ;
27823   Dali::BaseHandle arg1 ;
27824   Dali::BaseHandle *argp1 ;
27825   Dali::RenderTaskList result;
27826
27827   argp1 = (Dali::BaseHandle *)jarg1;
27828   if (!argp1) {
27829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27830     return 0;
27831   }
27832   arg1 = *argp1;
27833   {
27834     try {
27835       result = Dali::RenderTaskList::DownCast(arg1);
27836     } catch (std::out_of_range& e) {
27837       {
27838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (std::exception& e) {
27841       {
27842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (Dali::DaliException e) {
27845       {
27846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854
27855   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27861   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27862
27863   arg1 = (Dali::RenderTaskList *)jarg1;
27864   {
27865     try {
27866       delete arg1;
27867     } catch (std::out_of_range& e) {
27868       {
27869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27870       };
27871     } catch (std::exception& e) {
27872       {
27873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27874       };
27875     } catch (Dali::DaliException e) {
27876       {
27877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27878       };
27879     } catch (...) {
27880       {
27881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27882       };
27883     }
27884   }
27885
27886 }
27887
27888
27889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27890   void * jresult ;
27891   Dali::RenderTaskList *arg1 = 0 ;
27892   Dali::RenderTaskList *result = 0 ;
27893
27894   arg1 = (Dali::RenderTaskList *)jarg1;
27895   if (!arg1) {
27896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27897     return 0;
27898   }
27899   {
27900     try {
27901       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27902     } catch (std::out_of_range& e) {
27903       {
27904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27905       };
27906     } catch (std::exception& e) {
27907       {
27908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (Dali::DaliException e) {
27911       {
27912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920
27921   jresult = (void *)result;
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27927   void * jresult ;
27928   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27929   Dali::RenderTaskList *arg2 = 0 ;
27930   Dali::RenderTaskList *result = 0 ;
27931
27932   arg1 = (Dali::RenderTaskList *)jarg1;
27933   arg2 = (Dali::RenderTaskList *)jarg2;
27934   if (!arg2) {
27935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27936     return 0;
27937   }
27938   {
27939     try {
27940       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27956       };
27957     }
27958   }
27959
27960   jresult = (void *)result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27966   void * jresult ;
27967   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27968   Dali::RenderTask result;
27969
27970   arg1 = (Dali::RenderTaskList *)jarg1;
27971   {
27972     try {
27973       result = (arg1)->CreateTask();
27974     } catch (std::out_of_range& e) {
27975       {
27976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27977       };
27978     } catch (std::exception& e) {
27979       {
27980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27981       };
27982     } catch (Dali::DaliException e) {
27983       {
27984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27985       };
27986     } catch (...) {
27987       {
27988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27989       };
27990     }
27991   }
27992
27993   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27994   return jresult;
27995 }
27996
27997
27998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27999   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28000   Dali::RenderTask arg2 ;
28001   Dali::RenderTask *argp2 ;
28002
28003   arg1 = (Dali::RenderTaskList *)jarg1;
28004   argp2 = (Dali::RenderTask *)jarg2;
28005   if (!argp2) {
28006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
28007     return ;
28008   }
28009   arg2 = *argp2;
28010   {
28011     try {
28012       (arg1)->RemoveTask(arg2);
28013     } catch (std::out_of_range& e) {
28014       {
28015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28016       };
28017     } catch (std::exception& e) {
28018       {
28019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28020       };
28021     } catch (Dali::DaliException e) {
28022       {
28023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28024       };
28025     } catch (...) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28028       };
28029     }
28030   }
28031
28032 }
28033
28034
28035 //// ===============================================end part 1 =================
28036
28037 //// ========================= part 2 ===============================
28038
28039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
28040   unsigned int jresult ;
28041   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28042   unsigned int result;
28043
28044   arg1 = (Dali::RenderTaskList *)jarg1;
28045   {
28046     try {
28047       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
28048     } catch (std::out_of_range& e) {
28049       {
28050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28051       };
28052     } catch (std::exception& e) {
28053       {
28054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28055       };
28056     } catch (Dali::DaliException e) {
28057       {
28058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28059       };
28060     } catch (...) {
28061       {
28062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28063       };
28064     }
28065   }
28066
28067   jresult = result;
28068   return jresult;
28069 }
28070
28071
28072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28073   void * jresult ;
28074   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28075   unsigned int arg2 ;
28076   Dali::RenderTask result;
28077
28078   arg1 = (Dali::RenderTaskList *)jarg1;
28079   arg2 = (unsigned int)jarg2;
28080   {
28081     try {
28082       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28083     } catch (std::out_of_range& e) {
28084       {
28085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28086       };
28087     } catch (std::exception& e) {
28088       {
28089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (Dali::DaliException e) {
28092       {
28093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28094       };
28095     } catch (...) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28098       };
28099     }
28100   }
28101
28102   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28103   return jresult;
28104 }
28105
28106
28107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28108   int jresult ;
28109   int result;
28110
28111   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28112   jresult = (int)result;
28113   return jresult;
28114 }
28115
28116
28117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28118   int jresult ;
28119   int result;
28120
28121   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28122   jresult = (int)result;
28123   return jresult;
28124 }
28125
28126
28127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28128   int jresult ;
28129   int result;
28130
28131   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28132   jresult = (int)result;
28133   return jresult;
28134 }
28135
28136
28137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28138   int jresult ;
28139   int result;
28140
28141   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28142   jresult = (int)result;
28143   return jresult;
28144 }
28145
28146
28147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28148   void * jresult ;
28149   Dali::RenderTask::Property *result = 0 ;
28150
28151   {
28152     try {
28153       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28154     } catch (std::out_of_range& e) {
28155       {
28156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28157       };
28158     } catch (std::exception& e) {
28159       {
28160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28161       };
28162     } catch (Dali::DaliException e) {
28163       {
28164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28165       };
28166     } catch (...) {
28167       {
28168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28169       };
28170     }
28171   }
28172
28173   jresult = (void *)result;
28174   return jresult;
28175 }
28176
28177
28178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28179   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28180
28181   arg1 = (Dali::RenderTask::Property *)jarg1;
28182   {
28183     try {
28184       delete arg1;
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28192       };
28193     } catch (Dali::DaliException e) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28196       };
28197     } catch (...) {
28198       {
28199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28200       };
28201     }
28202   }
28203
28204 }
28205
28206
28207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28208   void * jresult ;
28209   bool (*result)(Dali::Vector2 &) = 0 ;
28210
28211   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28212   jresult = (void *)result;
28213   return jresult;
28214 }
28215
28216
28217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28218   void * jresult ;
28219   bool (*result)(Dali::Vector2 &) = 0 ;
28220
28221   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28222   jresult = (void *)result;
28223   return jresult;
28224 }
28225
28226
28227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28228   unsigned int jresult ;
28229   bool result;
28230
28231   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28232   jresult = result;
28233   return jresult;
28234 }
28235
28236
28237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28238   unsigned int jresult ;
28239   bool result;
28240
28241   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28242   jresult = result;
28243   return jresult;
28244 }
28245
28246
28247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28248   void * jresult ;
28249   Dali::Vector4 *result = 0 ;
28250
28251   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28252   jresult = (void *)result;
28253   return jresult;
28254 }
28255
28256
28257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28258   unsigned int jresult ;
28259   bool result;
28260
28261   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28262   jresult = result;
28263   return jresult;
28264 }
28265
28266
28267 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28268   unsigned int jresult ;
28269   bool result;
28270
28271   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28272   jresult = result;
28273   return jresult;
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28278   unsigned int jresult ;
28279   unsigned int result;
28280
28281   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28282   jresult = result;
28283   return jresult;
28284 }
28285
28286
28287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28288   void * jresult ;
28289   Dali::RenderTask *result = 0 ;
28290
28291   {
28292     try {
28293       result = (Dali::RenderTask *)new Dali::RenderTask();
28294     } catch (std::out_of_range& e) {
28295       {
28296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28297       };
28298     } catch (std::exception& e) {
28299       {
28300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28301       };
28302     } catch (Dali::DaliException e) {
28303       {
28304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28305       };
28306     } catch (...) {
28307       {
28308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28309       };
28310     }
28311   }
28312
28313   jresult = (void *)result;
28314   return jresult;
28315 }
28316
28317
28318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28319   void * jresult ;
28320   Dali::BaseHandle arg1 ;
28321   Dali::BaseHandle *argp1 ;
28322   Dali::RenderTask result;
28323
28324   argp1 = (Dali::BaseHandle *)jarg1;
28325   if (!argp1) {
28326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28327     return 0;
28328   }
28329   arg1 = *argp1;
28330   {
28331     try {
28332       result = Dali::RenderTask::DownCast(arg1);
28333     } catch (std::out_of_range& e) {
28334       {
28335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28336       };
28337     } catch (std::exception& e) {
28338       {
28339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28340       };
28341     } catch (Dali::DaliException e) {
28342       {
28343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28344       };
28345     } catch (...) {
28346       {
28347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28348       };
28349     }
28350   }
28351
28352   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28358   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28359
28360   arg1 = (Dali::RenderTask *)jarg1;
28361   {
28362     try {
28363       delete arg1;
28364     } catch (std::out_of_range& e) {
28365       {
28366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28367       };
28368     } catch (std::exception& e) {
28369       {
28370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28371       };
28372     } catch (Dali::DaliException e) {
28373       {
28374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28375       };
28376     } catch (...) {
28377       {
28378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28379       };
28380     }
28381   }
28382
28383 }
28384
28385
28386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28387   void * jresult ;
28388   Dali::RenderTask *arg1 = 0 ;
28389   Dali::RenderTask *result = 0 ;
28390
28391   arg1 = (Dali::RenderTask *)jarg1;
28392   if (!arg1) {
28393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28394     return 0;
28395   }
28396   {
28397     try {
28398       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28399     } catch (std::out_of_range& e) {
28400       {
28401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28402       };
28403     } catch (std::exception& e) {
28404       {
28405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28406       };
28407     } catch (Dali::DaliException e) {
28408       {
28409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28410       };
28411     } catch (...) {
28412       {
28413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28414       };
28415     }
28416   }
28417
28418   jresult = (void *)result;
28419   return jresult;
28420 }
28421
28422
28423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28424   void * jresult ;
28425   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28426   Dali::RenderTask *arg2 = 0 ;
28427   Dali::RenderTask *result = 0 ;
28428
28429   arg1 = (Dali::RenderTask *)jarg1;
28430   arg2 = (Dali::RenderTask *)jarg2;
28431   if (!arg2) {
28432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28433     return 0;
28434   }
28435   {
28436     try {
28437       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28438     } catch (std::out_of_range& e) {
28439       {
28440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28441       };
28442     } catch (std::exception& e) {
28443       {
28444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (Dali::DaliException e) {
28447       {
28448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28449       };
28450     } catch (...) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28453       };
28454     }
28455   }
28456
28457   jresult = (void *)result;
28458   return jresult;
28459 }
28460
28461
28462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28463   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28464   Dali::Actor arg2 ;
28465   Dali::Actor *argp2 ;
28466
28467   arg1 = (Dali::RenderTask *)jarg1;
28468   argp2 = (Dali::Actor *)jarg2;
28469   if (!argp2) {
28470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28471     return ;
28472   }
28473   arg2 = *argp2;
28474   {
28475     try {
28476       (arg1)->SetSourceActor(arg2);
28477     } catch (std::out_of_range& e) {
28478       {
28479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28480       };
28481     } catch (std::exception& e) {
28482       {
28483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (Dali::DaliException e) {
28486       {
28487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28488       };
28489     } catch (...) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28492       };
28493     }
28494   }
28495
28496 }
28497
28498
28499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28500   void * jresult ;
28501   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28502   Dali::Actor result;
28503
28504   arg1 = (Dali::RenderTask *)jarg1;
28505   {
28506     try {
28507       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28508     } catch (std::out_of_range& e) {
28509       {
28510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28511       };
28512     } catch (std::exception& e) {
28513       {
28514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (Dali::DaliException e) {
28517       {
28518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28519       };
28520     } catch (...) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28523       };
28524     }
28525   }
28526
28527   jresult = new Dali::Actor((const Dali::Actor &)result);
28528   return jresult;
28529 }
28530
28531
28532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28533   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28534   bool arg2 ;
28535
28536   arg1 = (Dali::RenderTask *)jarg1;
28537   arg2 = jarg2 ? true : false;
28538   {
28539     try {
28540       (arg1)->SetExclusive(arg2);
28541     } catch (std::out_of_range& e) {
28542       {
28543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28544       };
28545     } catch (std::exception& e) {
28546       {
28547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28548       };
28549     } catch (Dali::DaliException e) {
28550       {
28551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28552       };
28553     } catch (...) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28556       };
28557     }
28558   }
28559
28560 }
28561
28562
28563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28564   unsigned int jresult ;
28565   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28566   bool result;
28567
28568   arg1 = (Dali::RenderTask *)jarg1;
28569   {
28570     try {
28571       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28572     } catch (std::out_of_range& e) {
28573       {
28574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28575       };
28576     } catch (std::exception& e) {
28577       {
28578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28579       };
28580     } catch (Dali::DaliException e) {
28581       {
28582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28583       };
28584     } catch (...) {
28585       {
28586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28587       };
28588     }
28589   }
28590
28591   jresult = result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28598   bool arg2 ;
28599
28600   arg1 = (Dali::RenderTask *)jarg1;
28601   arg2 = jarg2 ? true : false;
28602   {
28603     try {
28604       (arg1)->SetInputEnabled(arg2);
28605     } catch (std::out_of_range& e) {
28606       {
28607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28608       };
28609     } catch (std::exception& e) {
28610       {
28611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28612       };
28613     } catch (Dali::DaliException e) {
28614       {
28615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28616       };
28617     } catch (...) {
28618       {
28619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28620       };
28621     }
28622   }
28623
28624 }
28625
28626
28627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28628   unsigned int jresult ;
28629   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28630   bool result;
28631
28632   arg1 = (Dali::RenderTask *)jarg1;
28633   {
28634     try {
28635       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28636     } catch (std::out_of_range& e) {
28637       {
28638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28639       };
28640     } catch (std::exception& e) {
28641       {
28642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28643       };
28644     } catch (Dali::DaliException e) {
28645       {
28646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28647       };
28648     } catch (...) {
28649       {
28650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28651       };
28652     }
28653   }
28654
28655   jresult = result;
28656   return jresult;
28657 }
28658
28659
28660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28661   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28662   Dali::CameraActor arg2 ;
28663   Dali::CameraActor *argp2 ;
28664
28665   arg1 = (Dali::RenderTask *)jarg1;
28666   argp2 = (Dali::CameraActor *)jarg2;
28667   if (!argp2) {
28668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28669     return ;
28670   }
28671   arg2 = *argp2;
28672   {
28673     try {
28674       (arg1)->SetCameraActor(arg2);
28675     } catch (std::out_of_range& e) {
28676       {
28677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28678       };
28679     } catch (std::exception& e) {
28680       {
28681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28682       };
28683     } catch (Dali::DaliException e) {
28684       {
28685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28686       };
28687     } catch (...) {
28688       {
28689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28690       };
28691     }
28692   }
28693
28694 }
28695
28696
28697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28698   void * jresult ;
28699   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28700   Dali::CameraActor result;
28701
28702   arg1 = (Dali::RenderTask *)jarg1;
28703   {
28704     try {
28705       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28706     } catch (std::out_of_range& e) {
28707       {
28708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28709       };
28710     } catch (std::exception& e) {
28711       {
28712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28713       };
28714     } catch (Dali::DaliException e) {
28715       {
28716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28717       };
28718     } catch (...) {
28719       {
28720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28721       };
28722     }
28723   }
28724
28725   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28726   return jresult;
28727 }
28728
28729
28730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28731   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28732   Dali::FrameBufferImage arg2 ;
28733   Dali::FrameBufferImage *argp2 ;
28734
28735   arg1 = (Dali::RenderTask *)jarg1;
28736   argp2 = (Dali::FrameBufferImage *)jarg2;
28737   if (!argp2) {
28738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28739     return ;
28740   }
28741   arg2 = *argp2;
28742   {
28743     try {
28744       (arg1)->SetTargetFrameBuffer(arg2);
28745     } catch (std::out_of_range& e) {
28746       {
28747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28748       };
28749     } catch (std::exception& e) {
28750       {
28751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (Dali::DaliException e) {
28754       {
28755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28756       };
28757     } catch (...) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28760       };
28761     }
28762   }
28763
28764 }
28765
28766
28767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28768   void * jresult ;
28769   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28770   Dali::FrameBufferImage result;
28771
28772   arg1 = (Dali::RenderTask *)jarg1;
28773   {
28774     try {
28775       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28776     } catch (std::out_of_range& e) {
28777       {
28778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28779       };
28780     } catch (std::exception& e) {
28781       {
28782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (Dali::DaliException e) {
28785       {
28786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28787       };
28788     } catch (...) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28791       };
28792     }
28793   }
28794
28795   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28796   return jresult;
28797 }
28798
28799
28800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28801   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28802   Dali::FrameBuffer arg2 ;
28803   Dali::FrameBuffer *argp2 ;
28804
28805   arg1 = (Dali::RenderTask *)jarg1;
28806   argp2 = (Dali::FrameBuffer *)jarg2;
28807   if (!argp2) {
28808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28809     return ;
28810   }
28811   arg2 = *argp2;
28812   {
28813     try {
28814       (arg1)->SetFrameBuffer(arg2);
28815     } catch (std::out_of_range& e) {
28816       {
28817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28818       };
28819     } catch (std::exception& e) {
28820       {
28821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28822       };
28823     } catch (Dali::DaliException e) {
28824       {
28825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28826       };
28827     } catch (...) {
28828       {
28829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28830       };
28831     }
28832   }
28833
28834 }
28835
28836
28837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28838   void * jresult ;
28839   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28840   Dali::FrameBuffer result;
28841
28842   arg1 = (Dali::RenderTask *)jarg1;
28843   {
28844     try {
28845       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28846     } catch (std::out_of_range& e) {
28847       {
28848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28849       };
28850     } catch (std::exception& e) {
28851       {
28852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28853       };
28854     } catch (Dali::DaliException e) {
28855       {
28856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28857       };
28858     } catch (...) {
28859       {
28860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28861       };
28862     }
28863   }
28864
28865   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28866   return jresult;
28867 }
28868
28869
28870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28871   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28872   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28873
28874   arg1 = (Dali::RenderTask *)jarg1;
28875   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28876   {
28877     try {
28878       (arg1)->SetScreenToFrameBufferFunction(arg2);
28879     } catch (std::out_of_range& e) {
28880       {
28881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28882       };
28883     } catch (std::exception& e) {
28884       {
28885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28886       };
28887     } catch (Dali::DaliException e) {
28888       {
28889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28890       };
28891     } catch (...) {
28892       {
28893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28894       };
28895     }
28896   }
28897
28898 }
28899
28900
28901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28902   void * jresult ;
28903   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28904   Dali::RenderTask::ScreenToFrameBufferFunction result;
28905
28906   arg1 = (Dali::RenderTask *)jarg1;
28907   {
28908     try {
28909       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28910     } catch (std::out_of_range& e) {
28911       {
28912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28913       };
28914     } catch (std::exception& e) {
28915       {
28916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28917       };
28918     } catch (Dali::DaliException e) {
28919       {
28920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28921       };
28922     } catch (...) {
28923       {
28924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28925       };
28926     }
28927   }
28928
28929   jresult = (void *)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28935   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28936   Dali::Actor arg2 ;
28937   Dali::Actor *argp2 ;
28938
28939   arg1 = (Dali::RenderTask *)jarg1;
28940   argp2 = (Dali::Actor *)jarg2;
28941   if (!argp2) {
28942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28943     return ;
28944   }
28945   arg2 = *argp2;
28946   {
28947     try {
28948       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28949     } catch (std::out_of_range& e) {
28950       {
28951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28952       };
28953     } catch (std::exception& e) {
28954       {
28955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28956       };
28957     } catch (Dali::DaliException e) {
28958       {
28959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28960       };
28961     } catch (...) {
28962       {
28963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28964       };
28965     }
28966   }
28967
28968 }
28969
28970
28971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28972   void * jresult ;
28973   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28974   Dali::Actor result;
28975
28976   arg1 = (Dali::RenderTask *)jarg1;
28977   {
28978     try {
28979       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28980     } catch (std::out_of_range& e) {
28981       {
28982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28983       };
28984     } catch (std::exception& e) {
28985       {
28986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28987       };
28988     } catch (Dali::DaliException e) {
28989       {
28990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28991       };
28992     } catch (...) {
28993       {
28994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28995       };
28996     }
28997   }
28998
28999   jresult = new Dali::Actor((const Dali::Actor &)result);
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
29005   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29006   Dali::Vector2 arg2 ;
29007   Dali::Vector2 *argp2 ;
29008
29009   arg1 = (Dali::RenderTask *)jarg1;
29010   argp2 = (Dali::Vector2 *)jarg2;
29011   if (!argp2) {
29012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29013     return ;
29014   }
29015   arg2 = *argp2;
29016   {
29017     try {
29018       (arg1)->SetViewportPosition(arg2);
29019     } catch (std::out_of_range& e) {
29020       {
29021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29022       };
29023     } catch (std::exception& e) {
29024       {
29025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (Dali::DaliException e) {
29028       {
29029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29030       };
29031     } catch (...) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29034       };
29035     }
29036   }
29037
29038 }
29039
29040
29041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
29042   void * jresult ;
29043   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29044   Dali::Vector2 result;
29045
29046   arg1 = (Dali::RenderTask *)jarg1;
29047   {
29048     try {
29049       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
29050     } catch (std::out_of_range& e) {
29051       {
29052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29053       };
29054     } catch (std::exception& e) {
29055       {
29056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (Dali::DaliException e) {
29059       {
29060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29061       };
29062     } catch (...) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29065       };
29066     }
29067   }
29068
29069   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29075   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29076   Dali::Vector2 arg2 ;
29077   Dali::Vector2 *argp2 ;
29078
29079   arg1 = (Dali::RenderTask *)jarg1;
29080   argp2 = (Dali::Vector2 *)jarg2;
29081   if (!argp2) {
29082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29083     return ;
29084   }
29085   arg2 = *argp2;
29086   {
29087     try {
29088       (arg1)->SetViewportSize(arg2);
29089     } catch (std::out_of_range& e) {
29090       {
29091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29092       };
29093     } catch (std::exception& e) {
29094       {
29095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (Dali::DaliException e) {
29098       {
29099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29100       };
29101     } catch (...) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29104       };
29105     }
29106   }
29107
29108 }
29109
29110
29111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29112   void * jresult ;
29113   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29114   Dali::Vector2 result;
29115
29116   arg1 = (Dali::RenderTask *)jarg1;
29117   {
29118     try {
29119       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29120     } catch (std::out_of_range& e) {
29121       {
29122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29123       };
29124     } catch (std::exception& e) {
29125       {
29126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (Dali::DaliException e) {
29129       {
29130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29131       };
29132     } catch (...) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29135       };
29136     }
29137   }
29138
29139   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29140   return jresult;
29141 }
29142
29143
29144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29145   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29146   Dali::Viewport arg2 ;
29147   Dali::Viewport *argp2 ;
29148
29149   arg1 = (Dali::RenderTask *)jarg1;
29150   argp2 = (Dali::Viewport *)jarg2;
29151   if (!argp2) {
29152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29153     return ;
29154   }
29155   arg2 = *argp2;
29156   {
29157     try {
29158       (arg1)->SetViewport(arg2);
29159     } catch (std::out_of_range& e) {
29160       {
29161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (std::exception& e) {
29164       {
29165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29166       };
29167     } catch (Dali::DaliException e) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29170       };
29171     } catch (...) {
29172       {
29173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29174       };
29175     }
29176   }
29177
29178 }
29179
29180
29181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29182   void * jresult ;
29183   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29184   Dali::Viewport result;
29185
29186   arg1 = (Dali::RenderTask *)jarg1;
29187   {
29188     try {
29189       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29190     } catch (std::out_of_range& e) {
29191       {
29192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (std::exception& e) {
29195       {
29196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29197       };
29198     } catch (Dali::DaliException e) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29201       };
29202     } catch (...) {
29203       {
29204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29205       };
29206     }
29207   }
29208
29209   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29210   return jresult;
29211 }
29212
29213
29214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29215   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29216   Dali::Vector4 *arg2 = 0 ;
29217
29218   arg1 = (Dali::RenderTask *)jarg1;
29219   arg2 = (Dali::Vector4 *)jarg2;
29220   if (!arg2) {
29221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29222     return ;
29223   }
29224   {
29225     try {
29226       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29227     } catch (std::out_of_range& e) {
29228       {
29229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29230       };
29231     } catch (std::exception& e) {
29232       {
29233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29234       };
29235     } catch (Dali::DaliException e) {
29236       {
29237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29238       };
29239     } catch (...) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29242       };
29243     }
29244   }
29245
29246 }
29247
29248
29249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29250   void * jresult ;
29251   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29252   Dali::Vector4 result;
29253
29254   arg1 = (Dali::RenderTask *)jarg1;
29255   {
29256     try {
29257       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29258     } catch (std::out_of_range& e) {
29259       {
29260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29261       };
29262     } catch (std::exception& e) {
29263       {
29264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (Dali::DaliException e) {
29267       {
29268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29269       };
29270     } catch (...) {
29271       {
29272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29273       };
29274     }
29275   }
29276
29277   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29278   return jresult;
29279 }
29280
29281
29282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29283   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29284   bool arg2 ;
29285
29286   arg1 = (Dali::RenderTask *)jarg1;
29287   arg2 = jarg2 ? true : false;
29288   {
29289     try {
29290       (arg1)->SetClearEnabled(arg2);
29291     } catch (std::out_of_range& e) {
29292       {
29293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29294       };
29295     } catch (std::exception& e) {
29296       {
29297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29298       };
29299     } catch (Dali::DaliException e) {
29300       {
29301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29302       };
29303     } catch (...) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29306       };
29307     }
29308   }
29309
29310 }
29311
29312
29313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29314   unsigned int jresult ;
29315   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29316   bool result;
29317
29318   arg1 = (Dali::RenderTask *)jarg1;
29319   {
29320     try {
29321       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29322     } catch (std::out_of_range& e) {
29323       {
29324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29325       };
29326     } catch (std::exception& e) {
29327       {
29328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (Dali::DaliException e) {
29331       {
29332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29333       };
29334     } catch (...) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29337       };
29338     }
29339   }
29340
29341   jresult = result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29347   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29348   bool arg2 ;
29349
29350   arg1 = (Dali::RenderTask *)jarg1;
29351   arg2 = jarg2 ? true : false;
29352   {
29353     try {
29354       (arg1)->SetCullMode(arg2);
29355     } catch (std::out_of_range& e) {
29356       {
29357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29358       };
29359     } catch (std::exception& e) {
29360       {
29361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29362       };
29363     } catch (Dali::DaliException e) {
29364       {
29365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29366       };
29367     } catch (...) {
29368       {
29369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29370       };
29371     }
29372   }
29373
29374 }
29375
29376
29377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29378   unsigned int jresult ;
29379   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29380   bool result;
29381
29382   arg1 = (Dali::RenderTask *)jarg1;
29383   {
29384     try {
29385       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29386     } catch (std::out_of_range& e) {
29387       {
29388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29389       };
29390     } catch (std::exception& e) {
29391       {
29392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29393       };
29394     } catch (Dali::DaliException e) {
29395       {
29396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29397       };
29398     } catch (...) {
29399       {
29400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29401       };
29402     }
29403   }
29404
29405   jresult = result;
29406   return jresult;
29407 }
29408
29409
29410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29411   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29412   unsigned int arg2 ;
29413
29414   arg1 = (Dali::RenderTask *)jarg1;
29415   arg2 = (unsigned int)jarg2;
29416   {
29417     try {
29418       (arg1)->SetRefreshRate(arg2);
29419     } catch (std::out_of_range& e) {
29420       {
29421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29422       };
29423     } catch (std::exception& e) {
29424       {
29425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29426       };
29427     } catch (Dali::DaliException e) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29430       };
29431     } catch (...) {
29432       {
29433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29434       };
29435     }
29436   }
29437
29438 }
29439
29440
29441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29442   unsigned int jresult ;
29443   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29444   unsigned int result;
29445
29446   arg1 = (Dali::RenderTask *)jarg1;
29447   {
29448     try {
29449       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29450     } catch (std::out_of_range& e) {
29451       {
29452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29453       };
29454     } catch (std::exception& e) {
29455       {
29456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29457       };
29458     } catch (Dali::DaliException e) {
29459       {
29460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29461       };
29462     } catch (...) {
29463       {
29464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29465       };
29466     }
29467   }
29468
29469   jresult = result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29475   unsigned int jresult ;
29476   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29477   Dali::Vector3 *arg2 = 0 ;
29478   float *arg3 = 0 ;
29479   float *arg4 = 0 ;
29480   bool result;
29481
29482   arg1 = (Dali::RenderTask *)jarg1;
29483   arg2 = (Dali::Vector3 *)jarg2;
29484   if (!arg2) {
29485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29486     return 0;
29487   }
29488   arg3 = (float *)jarg3;
29489   arg4 = (float *)jarg4;
29490   {
29491     try {
29492       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29493     } catch (std::out_of_range& e) {
29494       {
29495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29496       };
29497     } catch (std::exception& e) {
29498       {
29499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29500       };
29501     } catch (Dali::DaliException e) {
29502       {
29503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29504       };
29505     } catch (...) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29508       };
29509     }
29510   }
29511
29512   jresult = result;
29513   return jresult;
29514 }
29515
29516
29517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29518   unsigned int jresult ;
29519   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29520   Dali::Actor arg2 ;
29521   float arg3 ;
29522   float arg4 ;
29523   float *arg5 = 0 ;
29524   float *arg6 = 0 ;
29525   Dali::Actor *argp2 ;
29526   bool result;
29527
29528   arg1 = (Dali::RenderTask *)jarg1;
29529   argp2 = (Dali::Actor *)jarg2;
29530   if (!argp2) {
29531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29532     return 0;
29533   }
29534   arg2 = *argp2;
29535   arg3 = (float)jarg3;
29536   arg4 = (float)jarg4;
29537   arg5 = (float *)jarg5;
29538   arg6 = (float *)jarg6;
29539   {
29540     try {
29541       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29542     } catch (std::out_of_range& e) {
29543       {
29544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (std::exception& e) {
29547       {
29548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (Dali::DaliException e) {
29551       {
29552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560
29561   jresult = result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29567   void * jresult ;
29568   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29569   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29570
29571   arg1 = (Dali::RenderTask *)jarg1;
29572   {
29573     try {
29574       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29575     } catch (std::out_of_range& e) {
29576       {
29577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29578       };
29579     } catch (std::exception& e) {
29580       {
29581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29582       };
29583     } catch (Dali::DaliException e) {
29584       {
29585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29586       };
29587     } catch (...) {
29588       {
29589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29590       };
29591     }
29592   }
29593
29594   jresult = (void *)result;
29595   return jresult;
29596 }
29597
29598
29599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29600   void * jresult ;
29601   int arg1 ;
29602   Dali::TouchPoint::State arg2 ;
29603   float arg3 ;
29604   float arg4 ;
29605   Dali::TouchPoint *result = 0 ;
29606
29607   arg1 = (int)jarg1;
29608   arg2 = (Dali::TouchPoint::State)jarg2;
29609   arg3 = (float)jarg3;
29610   arg4 = (float)jarg4;
29611   {
29612     try {
29613       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29614     } catch (std::out_of_range& e) {
29615       {
29616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29617       };
29618     } catch (std::exception& e) {
29619       {
29620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29621       };
29622     } catch (Dali::DaliException e) {
29623       {
29624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29625       };
29626     } catch (...) {
29627       {
29628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29629       };
29630     }
29631   }
29632
29633   jresult = (void *)result;
29634   return jresult;
29635 }
29636
29637
29638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29639   void * jresult ;
29640   int arg1 ;
29641   Dali::TouchPoint::State arg2 ;
29642   float arg3 ;
29643   float arg4 ;
29644   float arg5 ;
29645   float arg6 ;
29646   Dali::TouchPoint *result = 0 ;
29647
29648   arg1 = (int)jarg1;
29649   arg2 = (Dali::TouchPoint::State)jarg2;
29650   arg3 = (float)jarg3;
29651   arg4 = (float)jarg4;
29652   arg5 = (float)jarg5;
29653   arg6 = (float)jarg6;
29654   {
29655     try {
29656       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29657     } catch (std::out_of_range& e) {
29658       {
29659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29660       };
29661     } catch (std::exception& e) {
29662       {
29663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29664       };
29665     } catch (Dali::DaliException e) {
29666       {
29667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29668       };
29669     } catch (...) {
29670       {
29671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29672       };
29673     }
29674   }
29675
29676   jresult = (void *)result;
29677   return jresult;
29678 }
29679
29680
29681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29682   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29683
29684   arg1 = (Dali::TouchPoint *)jarg1;
29685   {
29686     try {
29687       delete arg1;
29688     } catch (std::out_of_range& e) {
29689       {
29690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29691       };
29692     } catch (std::exception& e) {
29693       {
29694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29695       };
29696     } catch (Dali::DaliException e) {
29697       {
29698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29699       };
29700     } catch (...) {
29701       {
29702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29703       };
29704     }
29705   }
29706
29707 }
29708
29709
29710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29711   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29712   int arg2 ;
29713
29714   arg1 = (Dali::TouchPoint *)jarg1;
29715   arg2 = (int)jarg2;
29716   if (arg1) (arg1)->deviceId = arg2;
29717 }
29718
29719
29720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29721   int jresult ;
29722   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29723   int result;
29724
29725   arg1 = (Dali::TouchPoint *)jarg1;
29726   result = (int) ((arg1)->deviceId);
29727   jresult = result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29733   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29734   Dali::TouchPoint::State arg2 ;
29735
29736   arg1 = (Dali::TouchPoint *)jarg1;
29737   arg2 = (Dali::TouchPoint::State)jarg2;
29738   if (arg1) (arg1)->state = arg2;
29739 }
29740
29741
29742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29743   int jresult ;
29744   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29745   Dali::TouchPoint::State result;
29746
29747   arg1 = (Dali::TouchPoint *)jarg1;
29748   result = (Dali::TouchPoint::State) ((arg1)->state);
29749   jresult = (int)result;
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29755   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29756   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29757
29758   arg1 = (Dali::TouchPoint *)jarg1;
29759   arg2 = (Dali::Actor *)jarg2;
29760   if (arg1) (arg1)->hitActor = *arg2;
29761 }
29762
29763
29764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29765   void * jresult ;
29766   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29767   Dali::Actor *result = 0 ;
29768
29769   arg1 = (Dali::TouchPoint *)jarg1;
29770   result = (Dali::Actor *)& ((arg1)->hitActor);
29771   jresult = (void *)result;
29772   return jresult;
29773 }
29774
29775
29776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29777   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29778   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29779
29780   arg1 = (Dali::TouchPoint *)jarg1;
29781   arg2 = (Dali::Vector2 *)jarg2;
29782   if (arg1) (arg1)->local = *arg2;
29783 }
29784
29785
29786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29787   void * jresult ;
29788   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29789   Dali::Vector2 *result = 0 ;
29790
29791   arg1 = (Dali::TouchPoint *)jarg1;
29792   result = (Dali::Vector2 *)& ((arg1)->local);
29793   jresult = (void *)result;
29794   return jresult;
29795 }
29796
29797
29798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29799   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29800   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29801
29802   arg1 = (Dali::TouchPoint *)jarg1;
29803   arg2 = (Dali::Vector2 *)jarg2;
29804   if (arg1) (arg1)->screen = *arg2;
29805 }
29806
29807
29808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29809   void * jresult ;
29810   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29811   Dali::Vector2 *result = 0 ;
29812
29813   arg1 = (Dali::TouchPoint *)jarg1;
29814   result = (Dali::Vector2 *)& ((arg1)->screen);
29815   jresult = (void *)result;
29816   return jresult;
29817 }
29818
29819
29820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29821   void * jresult ;
29822   Dali::TouchData *result = 0 ;
29823
29824   {
29825     try {
29826       result = (Dali::TouchData *)new Dali::TouchData();
29827     } catch (std::out_of_range& e) {
29828       {
29829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29830       };
29831     } catch (std::exception& e) {
29832       {
29833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29834       };
29835     } catch (Dali::DaliException e) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29838       };
29839     } catch (...) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29842       };
29843     }
29844   }
29845
29846   jresult = (void *)result;
29847   return jresult;
29848 }
29849
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29852   void * jresult ;
29853   Dali::TouchData *arg1 = 0 ;
29854   Dali::TouchData *result = 0 ;
29855
29856   arg1 = (Dali::TouchData *)jarg1;
29857   if (!arg1) {
29858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29859     return 0;
29860   }
29861   {
29862     try {
29863       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29864     } catch (std::out_of_range& e) {
29865       {
29866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (std::exception& e) {
29869       {
29870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29871       };
29872     } catch (Dali::DaliException e) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29875       };
29876     } catch (...) {
29877       {
29878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29879       };
29880     }
29881   }
29882
29883   jresult = (void *)result;
29884   return jresult;
29885 }
29886
29887
29888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29889   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29890
29891   arg1 = (Dali::TouchData *)jarg1;
29892   {
29893     try {
29894       delete arg1;
29895     } catch (std::out_of_range& e) {
29896       {
29897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29898       };
29899     } catch (std::exception& e) {
29900       {
29901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29902       };
29903     } catch (Dali::DaliException e) {
29904       {
29905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29906       };
29907     } catch (...) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29910       };
29911     }
29912   }
29913
29914 }
29915
29916
29917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29918   void * jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   Dali::TouchData *arg2 = 0 ;
29921   Dali::TouchData *result = 0 ;
29922
29923   arg1 = (Dali::TouchData *)jarg1;
29924   arg2 = (Dali::TouchData *)jarg2;
29925   if (!arg2) {
29926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29927     return 0;
29928   }
29929   {
29930     try {
29931       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (Dali::DaliException e) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29943       };
29944     } catch (...) {
29945       {
29946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29947       };
29948     }
29949   }
29950
29951   jresult = (void *)result;
29952   return jresult;
29953 }
29954
29955
29956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29957   unsigned long jresult ;
29958   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29959   unsigned long result;
29960
29961   arg1 = (Dali::TouchData *)jarg1;
29962   {
29963     try {
29964       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29965     } catch (std::out_of_range& e) {
29966       {
29967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (std::exception& e) {
29970       {
29971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29972       };
29973     } catch (Dali::DaliException e) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29976       };
29977     } catch (...) {
29978       {
29979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29980       };
29981     }
29982   }
29983
29984   jresult = (unsigned long)result;
29985   return jresult;
29986 }
29987
29988
29989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29990   unsigned long jresult ;
29991   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29992   std::size_t result;
29993
29994   arg1 = (Dali::TouchData *)jarg1;
29995   {
29996     try {
29997       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29998     } catch (std::out_of_range& e) {
29999       {
30000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30001       };
30002     } catch (std::exception& e) {
30003       {
30004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30005       };
30006     } catch (Dali::DaliException e) {
30007       {
30008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30009       };
30010     } catch (...) {
30011       {
30012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30013       };
30014     }
30015   }
30016
30017   jresult = (unsigned long)result;
30018   return jresult;
30019 }
30020
30021
30022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
30023   int jresult ;
30024   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30025   std::size_t arg2 ;
30026   int32_t result;
30027
30028   arg1 = (Dali::TouchData *)jarg1;
30029   arg2 = (std::size_t)jarg2;
30030   {
30031     try {
30032       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
30033     } catch (std::out_of_range& e) {
30034       {
30035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30036       };
30037     } catch (std::exception& e) {
30038       {
30039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (Dali::DaliException e) {
30042       {
30043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30044       };
30045     } catch (...) {
30046       {
30047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30048       };
30049     }
30050   }
30051
30052   jresult = result;
30053   return jresult;
30054 }
30055
30056
30057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
30058   int jresult ;
30059   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30060   std::size_t arg2 ;
30061   Dali::PointState::Type result;
30062
30063   arg1 = (Dali::TouchData *)jarg1;
30064   arg2 = (std::size_t)jarg2;
30065   {
30066     try {
30067       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30068     } catch (std::out_of_range& e) {
30069       {
30070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30071       };
30072     } catch (std::exception& e) {
30073       {
30074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30075       };
30076     } catch (Dali::DaliException e) {
30077       {
30078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30079       };
30080     } catch (...) {
30081       {
30082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30083       };
30084     }
30085   }
30086
30087   jresult = (int)result;
30088   return jresult;
30089 }
30090
30091
30092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30093   void * jresult ;
30094   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30095   std::size_t arg2 ;
30096   Dali::Actor result;
30097
30098   arg1 = (Dali::TouchData *)jarg1;
30099   arg2 = (std::size_t)jarg2;
30100   {
30101     try {
30102       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30103     } catch (std::out_of_range& e) {
30104       {
30105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30106       };
30107     } catch (std::exception& e) {
30108       {
30109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (Dali::DaliException e) {
30112       {
30113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30114       };
30115     } catch (...) {
30116       {
30117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30118       };
30119     }
30120   }
30121
30122   jresult = new Dali::Actor((const Dali::Actor &)result);
30123   return jresult;
30124 }
30125
30126
30127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30128   void * jresult ;
30129   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30130   std::size_t arg2 ;
30131   Dali::Vector2 *result = 0 ;
30132
30133   arg1 = (Dali::TouchData *)jarg1;
30134   arg2 = (std::size_t)jarg2;
30135   {
30136     try {
30137       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30138     } catch (std::out_of_range& e) {
30139       {
30140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30141       };
30142     } catch (std::exception& e) {
30143       {
30144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30145       };
30146     } catch (Dali::DaliException e) {
30147       {
30148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30149       };
30150     } catch (...) {
30151       {
30152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30153       };
30154     }
30155   }
30156
30157   jresult = (void *)result;
30158   return jresult;
30159 }
30160
30161
30162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30163   void * jresult ;
30164   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30165   std::size_t arg2 ;
30166   Dali::Vector2 *result = 0 ;
30167
30168   arg1 = (Dali::TouchData *)jarg1;
30169   arg2 = (std::size_t)jarg2;
30170   {
30171     try {
30172       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30173     } catch (std::out_of_range& e) {
30174       {
30175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30176       };
30177     } catch (std::exception& e) {
30178       {
30179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30180       };
30181     } catch (Dali::DaliException e) {
30182       {
30183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30184       };
30185     } catch (...) {
30186       {
30187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30188       };
30189     }
30190   }
30191
30192   jresult = (void *)result;
30193   return jresult;
30194 }
30195
30196
30197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30198   float jresult ;
30199   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30200   std::size_t arg2 ;
30201   float result;
30202
30203   arg1 = (Dali::TouchData *)jarg1;
30204   arg2 = (std::size_t)jarg2;
30205   {
30206     try {
30207       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30208     } catch (std::out_of_range& e) {
30209       {
30210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30211       };
30212     } catch (std::exception& e) {
30213       {
30214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30215       };
30216     } catch (Dali::DaliException e) {
30217       {
30218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30219       };
30220     } catch (...) {
30221       {
30222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30223       };
30224     }
30225   }
30226
30227   jresult = result;
30228   return jresult;
30229 }
30230
30231
30232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30233   void * jresult ;
30234   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30235   std::size_t arg2 ;
30236   Dali::Vector2 *result = 0 ;
30237
30238   arg1 = (Dali::TouchData *)jarg1;
30239   arg2 = (std::size_t)jarg2;
30240   {
30241     try {
30242       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30243     } catch (std::out_of_range& e) {
30244       {
30245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30246       };
30247     } catch (std::exception& e) {
30248       {
30249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (Dali::DaliException e) {
30252       {
30253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30254       };
30255     } catch (...) {
30256       {
30257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30258       };
30259     }
30260   }
30261
30262   jresult = (void *)result;
30263   return jresult;
30264 }
30265
30266
30267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30268   float jresult ;
30269   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30270   std::size_t arg2 ;
30271   float result;
30272
30273   arg1 = (Dali::TouchData *)jarg1;
30274   arg2 = (std::size_t)jarg2;
30275   {
30276     try {
30277       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30278     } catch (std::out_of_range& e) {
30279       {
30280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30281       };
30282     } catch (std::exception& e) {
30283       {
30284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30285       };
30286     } catch (Dali::DaliException e) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30293       };
30294     }
30295   }
30296
30297   jresult = result;
30298   return jresult;
30299 }
30300
30301
30302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30303   void * jresult ;
30304   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30305   std::size_t arg2 ;
30306   Dali::Degree result;
30307
30308   arg1 = (Dali::TouchData *)jarg1;
30309   arg2 = (std::size_t)jarg2;
30310   {
30311     try {
30312       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30313     } catch (std::out_of_range& e) {
30314       {
30315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30316       };
30317     } catch (std::exception& e) {
30318       {
30319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30320       };
30321     } catch (Dali::DaliException e) {
30322       {
30323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30324       };
30325     } catch (...) {
30326       {
30327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30328       };
30329     }
30330   }
30331
30332   jresult = new Dali::Degree((const Dali::Degree &)result);
30333   return jresult;
30334 }
30335
30336
30337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30338   int jresult ;
30339   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30340   std::size_t arg2 ;
30341   Dali::MouseButton::Type result;
30342
30343   arg1 = (Dali::TouchData *)jarg1;
30344   arg2 = (std::size_t)jarg2;
30345   {
30346     try {
30347       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30348     } catch (std::out_of_range& e) {
30349       {
30350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30351       };
30352     } catch (std::exception& e) {
30353       {
30354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30355       };
30356     } catch (Dali::DaliException e) {
30357       {
30358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30363       };
30364     }
30365   }
30366
30367   jresult = static_cast< int >(result);
30368   return jresult;
30369 }
30370
30371
30372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30373   void * jresult ;
30374   Dali::GestureDetector *result = 0 ;
30375
30376   {
30377     try {
30378       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30379     } catch (std::out_of_range& e) {
30380       {
30381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30382       };
30383     } catch (std::exception& e) {
30384       {
30385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30386       };
30387     } catch (Dali::DaliException e) {
30388       {
30389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30390       };
30391     } catch (...) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30394       };
30395     }
30396   }
30397
30398   jresult = (void *)result;
30399   return jresult;
30400 }
30401
30402
30403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30404   void * jresult ;
30405   Dali::BaseHandle arg1 ;
30406   Dali::BaseHandle *argp1 ;
30407   Dali::GestureDetector result;
30408
30409   argp1 = (Dali::BaseHandle *)jarg1;
30410   if (!argp1) {
30411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30412     return 0;
30413   }
30414   arg1 = *argp1;
30415   {
30416     try {
30417       result = Dali::GestureDetector::DownCast(arg1);
30418     } catch (std::out_of_range& e) {
30419       {
30420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30421       };
30422     } catch (std::exception& e) {
30423       {
30424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30425       };
30426     } catch (Dali::DaliException e) {
30427       {
30428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30429       };
30430     } catch (...) {
30431       {
30432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30433       };
30434     }
30435   }
30436
30437   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30438   return jresult;
30439 }
30440
30441
30442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30443   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30444
30445   arg1 = (Dali::GestureDetector *)jarg1;
30446   {
30447     try {
30448       delete arg1;
30449     } catch (std::out_of_range& e) {
30450       {
30451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30452       };
30453     } catch (std::exception& e) {
30454       {
30455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30456       };
30457     } catch (Dali::DaliException e) {
30458       {
30459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30460       };
30461     } catch (...) {
30462       {
30463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30464       };
30465     }
30466   }
30467
30468 }
30469
30470
30471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30472   void * jresult ;
30473   Dali::GestureDetector *arg1 = 0 ;
30474   Dali::GestureDetector *result = 0 ;
30475
30476   arg1 = (Dali::GestureDetector *)jarg1;
30477   if (!arg1) {
30478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30479     return 0;
30480   }
30481   {
30482     try {
30483       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30484     } catch (std::out_of_range& e) {
30485       {
30486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30487       };
30488     } catch (std::exception& e) {
30489       {
30490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30491       };
30492     } catch (Dali::DaliException e) {
30493       {
30494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30495       };
30496     } catch (...) {
30497       {
30498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30499       };
30500     }
30501   }
30502
30503   jresult = (void *)result;
30504   return jresult;
30505 }
30506
30507
30508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30509   void * jresult ;
30510   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30511   Dali::GestureDetector *arg2 = 0 ;
30512   Dali::GestureDetector *result = 0 ;
30513
30514   arg1 = (Dali::GestureDetector *)jarg1;
30515   arg2 = (Dali::GestureDetector *)jarg2;
30516   if (!arg2) {
30517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30518     return 0;
30519   }
30520   {
30521     try {
30522       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30523     } catch (std::out_of_range& e) {
30524       {
30525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30526       };
30527     } catch (std::exception& e) {
30528       {
30529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30530       };
30531     } catch (Dali::DaliException e) {
30532       {
30533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30534       };
30535     } catch (...) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30538       };
30539     }
30540   }
30541
30542   jresult = (void *)result;
30543   return jresult;
30544 }
30545
30546
30547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30548   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30549   Dali::Actor arg2 ;
30550   Dali::Actor *argp2 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   argp2 = (Dali::Actor *)jarg2;
30554   if (!argp2) {
30555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30556     return ;
30557   }
30558   arg2 = *argp2;
30559   {
30560     try {
30561       (arg1)->Attach(arg2);
30562     } catch (std::out_of_range& e) {
30563       {
30564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30565       };
30566     } catch (std::exception& e) {
30567       {
30568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (Dali::DaliException e) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30573       };
30574     } catch (...) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30577       };
30578     }
30579   }
30580
30581 }
30582
30583
30584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30585   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30586   Dali::Actor arg2 ;
30587   Dali::Actor *argp2 ;
30588
30589   arg1 = (Dali::GestureDetector *)jarg1;
30590   argp2 = (Dali::Actor *)jarg2;
30591   if (!argp2) {
30592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30593     return ;
30594   }
30595   arg2 = *argp2;
30596   {
30597     try {
30598       (arg1)->Detach(arg2);
30599     } catch (std::out_of_range& e) {
30600       {
30601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30602       };
30603     } catch (std::exception& e) {
30604       {
30605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30606       };
30607     } catch (Dali::DaliException e) {
30608       {
30609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30610       };
30611     } catch (...) {
30612       {
30613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30614       };
30615     }
30616   }
30617
30618 }
30619
30620
30621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30622   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30623
30624   arg1 = (Dali::GestureDetector *)jarg1;
30625   {
30626     try {
30627       (arg1)->DetachAll();
30628     } catch (std::out_of_range& e) {
30629       {
30630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30631       };
30632     } catch (std::exception& e) {
30633       {
30634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30635       };
30636     } catch (Dali::DaliException e) {
30637       {
30638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30639       };
30640     } catch (...) {
30641       {
30642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30643       };
30644     }
30645   }
30646
30647 }
30648
30649
30650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30651   unsigned long jresult ;
30652   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30653   size_t result;
30654
30655   arg1 = (Dali::GestureDetector *)jarg1;
30656   {
30657     try {
30658       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30659     } catch (std::out_of_range& e) {
30660       {
30661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30662       };
30663     } catch (std::exception& e) {
30664       {
30665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (Dali::DaliException e) {
30668       {
30669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677
30678   jresult = (unsigned long)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30684   void * jresult ;
30685   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30686   size_t arg2 ;
30687   Dali::Actor result;
30688
30689   arg1 = (Dali::GestureDetector *)jarg1;
30690   arg2 = (size_t)jarg2;
30691   {
30692     try {
30693       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30694     } catch (std::out_of_range& e) {
30695       {
30696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30697       };
30698     } catch (std::exception& e) {
30699       {
30700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (Dali::DaliException e) {
30703       {
30704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30705       };
30706     } catch (...) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30709       };
30710     }
30711   }
30712
30713   jresult = new Dali::Actor((const Dali::Actor &)result);
30714   return jresult;
30715 }
30716
30717
30718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30719   void * jresult ;
30720   Dali::Gesture *arg1 = 0 ;
30721   Dali::Gesture *result = 0 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   if (!arg1) {
30725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30726     return 0;
30727   }
30728   {
30729     try {
30730       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30731     } catch (std::out_of_range& e) {
30732       {
30733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30734       };
30735     } catch (std::exception& e) {
30736       {
30737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30738       };
30739     } catch (Dali::DaliException e) {
30740       {
30741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30742       };
30743     } catch (...) {
30744       {
30745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30746       };
30747     }
30748   }
30749
30750   jresult = (void *)result;
30751   return jresult;
30752 }
30753
30754
30755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30756   void * jresult ;
30757   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30758   Dali::Gesture *arg2 = 0 ;
30759   Dali::Gesture *result = 0 ;
30760
30761   arg1 = (Dali::Gesture *)jarg1;
30762   arg2 = (Dali::Gesture *)jarg2;
30763   if (!arg2) {
30764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30765     return 0;
30766   }
30767   {
30768     try {
30769       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30770     } catch (std::out_of_range& e) {
30771       {
30772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (std::exception& e) {
30775       {
30776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (Dali::DaliException e) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30781       };
30782     } catch (...) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30785       };
30786     }
30787   }
30788
30789   jresult = (void *)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30795   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30796
30797   arg1 = (Dali::Gesture *)jarg1;
30798   {
30799     try {
30800       delete arg1;
30801     } catch (std::out_of_range& e) {
30802       {
30803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30804       };
30805     } catch (std::exception& e) {
30806       {
30807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30808       };
30809     } catch (Dali::DaliException e) {
30810       {
30811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30812       };
30813     } catch (...) {
30814       {
30815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30816       };
30817     }
30818   }
30819
30820 }
30821
30822
30823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30824   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30825   Dali::Gesture::Type arg2 ;
30826
30827   arg1 = (Dali::Gesture *)jarg1;
30828   arg2 = (Dali::Gesture::Type)jarg2;
30829   if (arg1) (arg1)->type = arg2;
30830 }
30831
30832
30833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30834   int jresult ;
30835   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30836   Dali::Gesture::Type result;
30837
30838   arg1 = (Dali::Gesture *)jarg1;
30839   result = (Dali::Gesture::Type) ((arg1)->type);
30840   jresult = (int)result;
30841   return jresult;
30842 }
30843
30844
30845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30846   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30847   Dali::Gesture::State arg2 ;
30848
30849   arg1 = (Dali::Gesture *)jarg1;
30850   arg2 = (Dali::Gesture::State)jarg2;
30851   if (arg1) (arg1)->state = arg2;
30852 }
30853
30854
30855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30856   int jresult ;
30857   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30858   Dali::Gesture::State result;
30859
30860   arg1 = (Dali::Gesture *)jarg1;
30861   result = (Dali::Gesture::State) ((arg1)->state);
30862   jresult = (int)result;
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30868   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30869   unsigned int arg2 ;
30870
30871   arg1 = (Dali::Gesture *)jarg1;
30872   arg2 = (unsigned int)jarg2;
30873   if (arg1) (arg1)->time = arg2;
30874 }
30875
30876
30877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30878   unsigned int jresult ;
30879   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30880   unsigned int result;
30881
30882   arg1 = (Dali::Gesture *)jarg1;
30883   result = (unsigned int) ((arg1)->time);
30884   jresult = result;
30885   return jresult;
30886 }
30887
30888
30889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30890   void * jresult ;
30891   Dali::HoverEvent *result = 0 ;
30892
30893   {
30894     try {
30895       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30896     } catch (std::out_of_range& e) {
30897       {
30898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30899       };
30900     } catch (std::exception& e) {
30901       {
30902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30903       };
30904     } catch (Dali::DaliException e) {
30905       {
30906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30907       };
30908     } catch (...) {
30909       {
30910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30911       };
30912     }
30913   }
30914
30915   jresult = (void *)result;
30916   return jresult;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30921   void * jresult ;
30922   unsigned long arg1 ;
30923   Dali::HoverEvent *result = 0 ;
30924
30925   arg1 = (unsigned long)jarg1;
30926   {
30927     try {
30928       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30929     } catch (std::out_of_range& e) {
30930       {
30931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30932       };
30933     } catch (std::exception& e) {
30934       {
30935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30936       };
30937     } catch (Dali::DaliException e) {
30938       {
30939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30940       };
30941     } catch (...) {
30942       {
30943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30944       };
30945     }
30946   }
30947
30948   jresult = (void *)result;
30949   return jresult;
30950 }
30951
30952
30953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30954   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30955
30956   arg1 = (Dali::HoverEvent *)jarg1;
30957   {
30958     try {
30959       delete arg1;
30960     } catch (std::out_of_range& e) {
30961       {
30962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30963       };
30964     } catch (std::exception& e) {
30965       {
30966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30967       };
30968     } catch (Dali::DaliException e) {
30969       {
30970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30971       };
30972     } catch (...) {
30973       {
30974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30975       };
30976     }
30977   }
30978
30979 }
30980
30981
30982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30983   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30984   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30985
30986   arg1 = (Dali::HoverEvent *)jarg1;
30987   arg2 = (Dali::TouchPointContainer *)jarg2;
30988   if (arg1) (arg1)->points = *arg2;
30989 }
30990
30991
30992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30993   void * jresult ;
30994   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30995   Dali::TouchPointContainer *result = 0 ;
30996
30997   arg1 = (Dali::HoverEvent *)jarg1;
30998   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30999   jresult = (void *)result;
31000   return jresult;
31001 }
31002
31003
31004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
31005   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31006   unsigned long arg2 ;
31007
31008   arg1 = (Dali::HoverEvent *)jarg1;
31009   arg2 = (unsigned long)jarg2;
31010   if (arg1) (arg1)->time = arg2;
31011 }
31012
31013
31014 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
31015   unsigned long jresult ;
31016   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31017   unsigned long result;
31018
31019   arg1 = (Dali::HoverEvent *)jarg1;
31020   result = (unsigned long) ((arg1)->time);
31021   jresult = (unsigned long)result;
31022   return jresult;
31023 }
31024
31025
31026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
31027   unsigned int jresult ;
31028   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31029   unsigned int result;
31030
31031   arg1 = (Dali::HoverEvent *)jarg1;
31032   {
31033     try {
31034       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
31035     } catch (std::out_of_range& e) {
31036       {
31037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (std::exception& e) {
31040       {
31041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31042       };
31043     } catch (Dali::DaliException e) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31046       };
31047     } catch (...) {
31048       {
31049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31050       };
31051     }
31052   }
31053
31054   jresult = result;
31055   return jresult;
31056 }
31057
31058
31059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
31060   void * jresult ;
31061   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31062   unsigned int arg2 ;
31063   Dali::TouchPoint *result = 0 ;
31064
31065   arg1 = (Dali::HoverEvent *)jarg1;
31066   arg2 = (unsigned int)jarg2;
31067   {
31068     try {
31069       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31070     } catch (std::out_of_range& e) {
31071       {
31072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31073       };
31074     } catch (std::exception& e) {
31075       {
31076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31077       };
31078     } catch (Dali::DaliException e) {
31079       {
31080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31081       };
31082     } catch (...) {
31083       {
31084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31085       };
31086     }
31087   }
31088
31089   jresult = (void *)result;
31090   return jresult;
31091 }
31092
31093
31094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31095   void * jresult ;
31096   Dali::KeyEvent *result = 0 ;
31097
31098   {
31099     try {
31100       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31101     } catch (std::out_of_range& e) {
31102       {
31103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31104       };
31105     } catch (std::exception& e) {
31106       {
31107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31108       };
31109     } catch (Dali::DaliException e) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31112       };
31113     } catch (...) {
31114       {
31115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31116       };
31117     }
31118   }
31119
31120   jresult = (void *)result;
31121   return jresult;
31122 }
31123
31124
31125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31126   void * jresult ;
31127   std::string *arg1 = 0 ;
31128   std::string *arg2 = 0 ;
31129   int arg3 ;
31130   int arg4 ;
31131   unsigned long arg5 ;
31132   Dali::KeyEvent::State *arg6 = 0 ;
31133   Dali::KeyEvent::State temp6 ;
31134   Dali::KeyEvent *result = 0 ;
31135
31136   if (!jarg1) {
31137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31138     return 0;
31139   }
31140   std::string arg1_str(jarg1);
31141   arg1 = &arg1_str;
31142   if (!jarg2) {
31143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31144     return 0;
31145   }
31146   std::string arg2_str(jarg2);
31147   arg2 = &arg2_str;
31148   arg3 = (int)jarg3;
31149   arg4 = (int)jarg4;
31150   arg5 = (unsigned long)jarg5;
31151   temp6 = (Dali::KeyEvent::State)jarg6;
31152   arg6 = &temp6;
31153   {
31154     try {
31155       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31156     } catch (std::out_of_range& e) {
31157       {
31158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31159       };
31160     } catch (std::exception& e) {
31161       {
31162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31163       };
31164     } catch (Dali::DaliException e) {
31165       {
31166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31167       };
31168     } catch (...) {
31169       {
31170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31171       };
31172     }
31173   }
31174
31175   jresult = (void *)result;
31176
31177   //argout typemap for const std::string&
31178
31179
31180   //argout typemap for const std::string&
31181
31182   return jresult;
31183 }
31184
31185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31186   void * jresult ;
31187   Dali::KeyEvent *arg1 = 0 ;
31188   Dali::KeyEvent *result = 0 ;
31189
31190   arg1 = (Dali::KeyEvent *)jarg1;
31191   if (!arg1) {
31192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31193     return 0;
31194   }
31195   {
31196     try {
31197       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31198     } catch (std::out_of_range& e) {
31199       {
31200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31201       };
31202     } catch (std::exception& e) {
31203       {
31204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (Dali::DaliException e) {
31207       {
31208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216
31217   jresult = (void *)result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31223   void * jresult ;
31224   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31225   Dali::KeyEvent *arg2 = 0 ;
31226   Dali::KeyEvent *result = 0 ;
31227
31228   arg1 = (Dali::KeyEvent *)jarg1;
31229   arg2 = (Dali::KeyEvent *)jarg2;
31230   if (!arg2) {
31231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31232     return 0;
31233   }
31234   {
31235     try {
31236       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31237     } catch (std::out_of_range& e) {
31238       {
31239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31240       };
31241     } catch (std::exception& e) {
31242       {
31243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31244       };
31245     } catch (Dali::DaliException e) {
31246       {
31247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31248       };
31249     } catch (...) {
31250       {
31251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31252       };
31253     }
31254   }
31255
31256   jresult = (void *)result;
31257   return jresult;
31258 }
31259
31260
31261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31262   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   {
31266     try {
31267       delete arg1;
31268     } catch (std::out_of_range& e) {
31269       {
31270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31271       };
31272     } catch (std::exception& e) {
31273       {
31274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31275       };
31276     } catch (Dali::DaliException e) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31279       };
31280     } catch (...) {
31281       {
31282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31283       };
31284     }
31285   }
31286
31287 }
31288
31289
31290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31291   unsigned int jresult ;
31292   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31293   bool result;
31294
31295   arg1 = (Dali::KeyEvent *)jarg1;
31296   {
31297     try {
31298       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31299     } catch (std::out_of_range& e) {
31300       {
31301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31302       };
31303     } catch (std::exception& e) {
31304       {
31305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31306       };
31307     } catch (Dali::DaliException e) {
31308       {
31309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31310       };
31311     } catch (...) {
31312       {
31313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31314       };
31315     }
31316   }
31317
31318   jresult = result;
31319   return jresult;
31320 }
31321
31322
31323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31324   unsigned int jresult ;
31325   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31326   bool result;
31327
31328   arg1 = (Dali::KeyEvent *)jarg1;
31329   {
31330     try {
31331       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31332     } catch (std::out_of_range& e) {
31333       {
31334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31335       };
31336     } catch (std::exception& e) {
31337       {
31338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31339       };
31340     } catch (Dali::DaliException e) {
31341       {
31342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31343       };
31344     } catch (...) {
31345       {
31346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31347       };
31348     }
31349   }
31350
31351   jresult = result;
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31357   unsigned int jresult ;
31358   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31359   bool result;
31360
31361   arg1 = (Dali::KeyEvent *)jarg1;
31362   {
31363     try {
31364       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31365     } catch (std::out_of_range& e) {
31366       {
31367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (std::exception& e) {
31370       {
31371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31372       };
31373     } catch (Dali::DaliException e) {
31374       {
31375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31376       };
31377     } catch (...) {
31378       {
31379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31380       };
31381     }
31382   }
31383
31384   jresult = result;
31385   return jresult;
31386 }
31387
31388
31389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31390   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31391   std::string *arg2 = 0 ;
31392
31393   arg1 = (Dali::KeyEvent *)jarg1;
31394   if (!jarg2) {
31395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31396     return ;
31397   }
31398   std::string arg2_str(jarg2);
31399   arg2 = &arg2_str;
31400   if (arg1) (arg1)->keyPressedName = *arg2;
31401
31402   //argout typemap for const std::string&
31403
31404 }
31405
31406
31407 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31408   char * jresult ;
31409
31410   if( jarg1 == NULL )
31411   {
31412     jresult = SWIG_csharp_string_callback( "" );
31413   }
31414   else
31415   {
31416     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31417     std::string *result = 0;
31418
31419     arg1 = ( Dali::KeyEvent * )jarg1;
31420     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31421     jresult = SWIG_csharp_string_callback( result->c_str() );
31422   }
31423
31424   return jresult;
31425 }
31426
31427
31428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31429   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31430   std::string *arg2 = 0 ;
31431
31432   arg1 = (Dali::KeyEvent *)jarg1;
31433   if (!jarg2) {
31434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31435     return ;
31436   }
31437   std::string arg2_str(jarg2);
31438   arg2 = &arg2_str;
31439   if (arg1) (arg1)->keyPressed = *arg2;
31440
31441   //argout typemap for const std::string&
31442
31443 }
31444
31445
31446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31447   char * jresult ;
31448   if( NULL == jarg1 )
31449   {
31450     jresult = SWIG_csharp_string_callback( "" );
31451   }
31452   else
31453   {
31454     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31455     std::string *result = 0;
31456
31457     arg1 = ( Dali::KeyEvent * )jarg1;
31458     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31459     jresult = SWIG_csharp_string_callback( result->c_str() );
31460   }
31461   return jresult;
31462 }
31463
31464
31465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31466   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31467   int arg2 ;
31468
31469   arg1 = (Dali::KeyEvent *)jarg1;
31470   arg2 = (int)jarg2;
31471   if (arg1) (arg1)->keyCode = arg2;
31472 }
31473
31474
31475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31476   int jresult ;
31477   if( NULL == jarg1 )
31478   {
31479     jresult = -1;
31480   }
31481   else
31482   {
31483     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31484     int result;
31485
31486     arg1 = ( Dali::KeyEvent * )jarg1;
31487     result = (int)( ( arg1 )->keyCode );
31488     jresult = result;
31489   }
31490   return jresult;
31491 }
31492
31493
31494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31496   int arg2 ;
31497
31498   arg1 = (Dali::KeyEvent *)jarg1;
31499   arg2 = (int)jarg2;
31500   if (arg1) (arg1)->keyModifier = arg2;
31501 }
31502
31503
31504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31505   int jresult ;
31506   if( jarg1 == NULL )
31507   {
31508     jresult = -1;
31509   }
31510   else
31511   {
31512     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31513     int result;
31514
31515     arg1 = ( Dali::KeyEvent * )jarg1;
31516     result = (int)( ( arg1 )->keyModifier );
31517     jresult = result;
31518   }
31519   return jresult;
31520 }
31521
31522
31523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31524   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31525   unsigned long arg2 ;
31526
31527   arg1 = (Dali::KeyEvent *)jarg1;
31528   arg2 = (unsigned long)jarg2;
31529   if (arg1) (arg1)->time = arg2;
31530 }
31531
31532
31533 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31534   unsigned long jresult ;
31535   if( jarg1 == NULL )
31536   {
31537     jresult = 0;
31538   }
31539   else
31540   {
31541     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31542     unsigned long result;
31543
31544     arg1 = ( Dali::KeyEvent * )jarg1;
31545     result = (unsigned long)( ( arg1 )->time );
31546     jresult = (unsigned long)result;
31547   }
31548   return jresult;
31549 }
31550
31551
31552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31553   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31554   Dali::KeyEvent::State arg2 ;
31555
31556   arg1 = (Dali::KeyEvent *)jarg1;
31557   arg2 = (Dali::KeyEvent::State)jarg2;
31558   if (arg1) (arg1)->state = arg2;
31559 }
31560
31561
31562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31563   int jresult ;
31564   if( jarg1 == NULL )
31565   {
31566     jresult = -1;
31567   }
31568   else
31569   {
31570     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31571     Dali::KeyEvent::State result;
31572
31573     arg1 = ( Dali::KeyEvent * )jarg1;
31574     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31575     jresult = (int)result;
31576   }
31577   return jresult;
31578 }
31579
31580 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31581   char * jresult ;
31582   std::string result;
31583   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31584
31585   arg1 = (Dali::KeyEvent *)jarg1;
31586   if (!arg1) {
31587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31588     return 0;
31589   }
31590   {
31591     try {
31592       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31593     } catch (std::out_of_range& e) {
31594       {
31595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31596       };
31597     } catch (std::exception& e) {
31598       {
31599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31600       };
31601     } catch (Dali::DaliException e) {
31602       {
31603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31604       };
31605     } catch (...) {
31606       {
31607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31608       };
31609     }
31610
31611   }
31612
31613   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31614   return jresult;
31615 }
31616
31617
31618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31619   void * jresult ;
31620   Dali::LongPressGestureDetector *result = 0 ;
31621
31622   {
31623     try {
31624       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (Dali::DaliException e) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31636       };
31637     } catch (...) {
31638       {
31639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31640       };
31641     }
31642   }
31643
31644   jresult = (void *)result;
31645   return jresult;
31646 }
31647
31648
31649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31650   void * jresult ;
31651   Dali::LongPressGestureDetector result;
31652
31653   {
31654     try {
31655       result = Dali::LongPressGestureDetector::New();
31656     } catch (std::out_of_range& e) {
31657       {
31658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (std::exception& e) {
31661       {
31662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31663       };
31664     } catch (Dali::DaliException e) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31667       };
31668     } catch (...) {
31669       {
31670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31671       };
31672     }
31673   }
31674
31675   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31676   return jresult;
31677 }
31678
31679
31680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31681   void * jresult ;
31682   unsigned int arg1 ;
31683   Dali::LongPressGestureDetector result;
31684
31685   arg1 = (unsigned int)jarg1;
31686   {
31687     try {
31688       result = Dali::LongPressGestureDetector::New(arg1);
31689     } catch (std::out_of_range& e) {
31690       {
31691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31692       };
31693     } catch (std::exception& e) {
31694       {
31695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (Dali::DaliException e) {
31698       {
31699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31700       };
31701     } catch (...) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31704       };
31705     }
31706   }
31707
31708   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31709   return jresult;
31710 }
31711
31712
31713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31714   void * jresult ;
31715   unsigned int arg1 ;
31716   unsigned int arg2 ;
31717   Dali::LongPressGestureDetector result;
31718
31719   arg1 = (unsigned int)jarg1;
31720   arg2 = (unsigned int)jarg2;
31721   {
31722     try {
31723       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31724     } catch (std::out_of_range& e) {
31725       {
31726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31727       };
31728     } catch (std::exception& e) {
31729       {
31730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31731       };
31732     } catch (Dali::DaliException e) {
31733       {
31734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31735       };
31736     } catch (...) {
31737       {
31738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31739       };
31740     }
31741   }
31742
31743   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31744   return jresult;
31745 }
31746
31747
31748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31749   void * jresult ;
31750   Dali::BaseHandle arg1 ;
31751   Dali::BaseHandle *argp1 ;
31752   Dali::LongPressGestureDetector result;
31753
31754   argp1 = (Dali::BaseHandle *)jarg1;
31755   if (!argp1) {
31756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31757     return 0;
31758   }
31759   arg1 = *argp1;
31760   {
31761     try {
31762       result = Dali::LongPressGestureDetector::DownCast(arg1);
31763     } catch (std::out_of_range& e) {
31764       {
31765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31766       };
31767     } catch (std::exception& e) {
31768       {
31769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31770       };
31771     } catch (Dali::DaliException e) {
31772       {
31773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31778       };
31779     }
31780   }
31781
31782   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31783   return jresult;
31784 }
31785
31786
31787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31788   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31789
31790   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31791   {
31792     try {
31793       delete arg1;
31794     } catch (std::out_of_range& e) {
31795       {
31796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31797       };
31798     } catch (std::exception& e) {
31799       {
31800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31801       };
31802     } catch (Dali::DaliException e) {
31803       {
31804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31805       };
31806     } catch (...) {
31807       {
31808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31809       };
31810     }
31811   }
31812
31813 }
31814
31815
31816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31817   void * jresult ;
31818   Dali::LongPressGestureDetector *arg1 = 0 ;
31819   Dali::LongPressGestureDetector *result = 0 ;
31820
31821   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31822   if (!arg1) {
31823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31824     return 0;
31825   }
31826   {
31827     try {
31828       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31844       };
31845     }
31846   }
31847
31848   jresult = (void *)result;
31849   return jresult;
31850 }
31851
31852
31853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31854   void * jresult ;
31855   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31856   Dali::LongPressGestureDetector *arg2 = 0 ;
31857   Dali::LongPressGestureDetector *result = 0 ;
31858
31859   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31860   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31861   if (!arg2) {
31862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31863     return 0;
31864   }
31865   {
31866     try {
31867       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31893   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31894   unsigned int arg2 ;
31895
31896   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31897   arg2 = (unsigned int)jarg2;
31898   {
31899     try {
31900       (arg1)->SetTouchesRequired(arg2);
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31916       };
31917     }
31918   }
31919
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31924   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31925   unsigned int arg2 ;
31926   unsigned int arg3 ;
31927
31928   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31929   arg2 = (unsigned int)jarg2;
31930   arg3 = (unsigned int)jarg3;
31931   {
31932     try {
31933       (arg1)->SetTouchesRequired(arg2,arg3);
31934     } catch (std::out_of_range& e) {
31935       {
31936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31937       };
31938     } catch (std::exception& e) {
31939       {
31940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31941       };
31942     } catch (Dali::DaliException e) {
31943       {
31944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31945       };
31946     } catch (...) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31949       };
31950     }
31951   }
31952
31953 }
31954
31955
31956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31957   unsigned int jresult ;
31958   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31959   unsigned int result;
31960
31961   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31962   {
31963     try {
31964       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31965     } catch (std::out_of_range& e) {
31966       {
31967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31968       };
31969     } catch (std::exception& e) {
31970       {
31971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31972       };
31973     } catch (Dali::DaliException e) {
31974       {
31975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31976       };
31977     } catch (...) {
31978       {
31979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31980       };
31981     }
31982   }
31983
31984   jresult = result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31990   unsigned int jresult ;
31991   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31992   unsigned int result;
31993
31994   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31995   {
31996     try {
31997       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31998     } catch (std::out_of_range& e) {
31999       {
32000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32001       };
32002     } catch (std::exception& e) {
32003       {
32004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (Dali::DaliException e) {
32007       {
32008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32009       };
32010     } catch (...) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32013       };
32014     }
32015   }
32016
32017   jresult = result;
32018   return jresult;
32019 }
32020
32021
32022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32023   void * jresult ;
32024   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32025   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32026
32027   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32028   {
32029     try {
32030       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32031     } catch (std::out_of_range& e) {
32032       {
32033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32034       };
32035     } catch (std::exception& e) {
32036       {
32037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32038       };
32039     } catch (Dali::DaliException e) {
32040       {
32041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32042       };
32043     } catch (...) {
32044       {
32045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32046       };
32047     }
32048   }
32049
32050   jresult = (void *)result;
32051   return jresult;
32052 }
32053
32054
32055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32056   void * jresult ;
32057   Dali::Gesture::State arg1 ;
32058   Dali::LongPressGesture *result = 0 ;
32059
32060   arg1 = (Dali::Gesture::State)jarg1;
32061   {
32062     try {
32063       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32064     } catch (std::out_of_range& e) {
32065       {
32066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32067       };
32068     } catch (std::exception& e) {
32069       {
32070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (Dali::DaliException e) {
32073       {
32074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32075       };
32076     } catch (...) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32079       };
32080     }
32081   }
32082
32083   jresult = (void *)result;
32084   return jresult;
32085 }
32086
32087
32088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32089   void * jresult ;
32090   Dali::LongPressGesture *arg1 = 0 ;
32091   Dali::LongPressGesture *result = 0 ;
32092
32093   arg1 = (Dali::LongPressGesture *)jarg1;
32094   if (!arg1) {
32095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32096     return 0;
32097   }
32098   {
32099     try {
32100       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32101     } catch (std::out_of_range& e) {
32102       {
32103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32104       };
32105     } catch (std::exception& e) {
32106       {
32107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32108       };
32109     } catch (Dali::DaliException e) {
32110       {
32111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32112       };
32113     } catch (...) {
32114       {
32115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32116       };
32117     }
32118   }
32119
32120   jresult = (void *)result;
32121   return jresult;
32122 }
32123
32124
32125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32126   void * jresult ;
32127   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32128   Dali::LongPressGesture *arg2 = 0 ;
32129   Dali::LongPressGesture *result = 0 ;
32130
32131   arg1 = (Dali::LongPressGesture *)jarg1;
32132   arg2 = (Dali::LongPressGesture *)jarg2;
32133   if (!arg2) {
32134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32135     return 0;
32136   }
32137   {
32138     try {
32139       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32140     } catch (std::out_of_range& e) {
32141       {
32142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32143       };
32144     } catch (std::exception& e) {
32145       {
32146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32147       };
32148     } catch (Dali::DaliException e) {
32149       {
32150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32151       };
32152     } catch (...) {
32153       {
32154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32155       };
32156     }
32157   }
32158
32159   jresult = (void *)result;
32160   return jresult;
32161 }
32162
32163
32164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32165   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32166
32167   arg1 = (Dali::LongPressGesture *)jarg1;
32168   {
32169     try {
32170       delete arg1;
32171     } catch (std::out_of_range& e) {
32172       {
32173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32174       };
32175     } catch (std::exception& e) {
32176       {
32177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32178       };
32179     } catch (Dali::DaliException e) {
32180       {
32181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32182       };
32183     } catch (...) {
32184       {
32185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32186       };
32187     }
32188   }
32189
32190 }
32191
32192
32193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32194   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32195   unsigned int arg2 ;
32196
32197   arg1 = (Dali::LongPressGesture *)jarg1;
32198   arg2 = (unsigned int)jarg2;
32199   if (arg1) (arg1)->numberOfTouches = arg2;
32200 }
32201
32202
32203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32204   unsigned int jresult ;
32205   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32206   unsigned int result;
32207
32208   arg1 = (Dali::LongPressGesture *)jarg1;
32209   result = (unsigned int) ((arg1)->numberOfTouches);
32210   jresult = result;
32211   return jresult;
32212 }
32213
32214
32215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32216   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32217   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32218
32219   arg1 = (Dali::LongPressGesture *)jarg1;
32220   arg2 = (Dali::Vector2 *)jarg2;
32221   if (arg1) (arg1)->screenPoint = *arg2;
32222 }
32223
32224
32225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32226   void * jresult ;
32227   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32228   Dali::Vector2 *result = 0 ;
32229
32230   arg1 = (Dali::LongPressGesture *)jarg1;
32231   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32232   jresult = (void *)result;
32233   return jresult;
32234 }
32235
32236
32237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32238   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32239   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32240
32241   arg1 = (Dali::LongPressGesture *)jarg1;
32242   arg2 = (Dali::Vector2 *)jarg2;
32243   if (arg1) (arg1)->localPoint = *arg2;
32244 }
32245
32246
32247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32248   void * jresult ;
32249   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32250   Dali::Vector2 *result = 0 ;
32251
32252   arg1 = (Dali::LongPressGesture *)jarg1;
32253   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32254   jresult = (void *)result;
32255   return jresult;
32256 }
32257
32258
32259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32260   void * jresult ;
32261   Dali::WheelEvent *result = 0 ;
32262
32263   {
32264     try {
32265       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32266     } catch (std::out_of_range& e) {
32267       {
32268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32269       };
32270     } catch (std::exception& e) {
32271       {
32272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32273       };
32274     } catch (Dali::DaliException e) {
32275       {
32276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32277       };
32278     } catch (...) {
32279       {
32280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32281       };
32282     }
32283   }
32284
32285   jresult = (void *)result;
32286   return jresult;
32287 }
32288
32289
32290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32291   void * jresult ;
32292   Dali::WheelEvent::Type arg1 ;
32293   int arg2 ;
32294   unsigned int arg3 ;
32295   Dali::Vector2 arg4 ;
32296   int arg5 ;
32297   unsigned int arg6 ;
32298   Dali::Vector2 *argp4 ;
32299   Dali::WheelEvent *result = 0 ;
32300
32301   arg1 = (Dali::WheelEvent::Type)jarg1;
32302   arg2 = (int)jarg2;
32303   arg3 = (unsigned int)jarg3;
32304   argp4 = (Dali::Vector2 *)jarg4;
32305   if (!argp4) {
32306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32307     return 0;
32308   }
32309   arg4 = *argp4;
32310   arg5 = (int)jarg5;
32311   arg6 = (unsigned int)jarg6;
32312   {
32313     try {
32314       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32315     } catch (std::out_of_range& e) {
32316       {
32317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32318       };
32319     } catch (std::exception& e) {
32320       {
32321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (Dali::DaliException e) {
32324       {
32325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32326       };
32327     } catch (...) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32330       };
32331     }
32332   }
32333
32334   jresult = (void *)result;
32335   return jresult;
32336 }
32337
32338
32339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32340   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32341
32342   arg1 = (Dali::WheelEvent *)jarg1;
32343   {
32344     try {
32345       delete arg1;
32346     } catch (std::out_of_range& e) {
32347       {
32348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32349       };
32350     } catch (std::exception& e) {
32351       {
32352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32353       };
32354     } catch (Dali::DaliException e) {
32355       {
32356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32361       };
32362     }
32363   }
32364
32365 }
32366
32367
32368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32369   unsigned int jresult ;
32370   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32371   bool result;
32372
32373   arg1 = (Dali::WheelEvent *)jarg1;
32374   {
32375     try {
32376       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32377     } catch (std::out_of_range& e) {
32378       {
32379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32380       };
32381     } catch (std::exception& e) {
32382       {
32383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32384       };
32385     } catch (Dali::DaliException e) {
32386       {
32387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32388       };
32389     } catch (...) {
32390       {
32391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32392       };
32393     }
32394   }
32395
32396   jresult = result;
32397   return jresult;
32398 }
32399
32400
32401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32402   unsigned int jresult ;
32403   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32404   bool result;
32405
32406   arg1 = (Dali::WheelEvent *)jarg1;
32407   {
32408     try {
32409       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32410     } catch (std::out_of_range& e) {
32411       {
32412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32413       };
32414     } catch (std::exception& e) {
32415       {
32416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32417       };
32418     } catch (Dali::DaliException e) {
32419       {
32420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32421       };
32422     } catch (...) {
32423       {
32424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32425       };
32426     }
32427   }
32428
32429   jresult = result;
32430   return jresult;
32431 }
32432
32433
32434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32435   unsigned int jresult ;
32436   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32437   bool result;
32438
32439   arg1 = (Dali::WheelEvent *)jarg1;
32440   {
32441     try {
32442       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32443     } catch (std::out_of_range& e) {
32444       {
32445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32446       };
32447     } catch (std::exception& e) {
32448       {
32449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32450       };
32451     } catch (Dali::DaliException e) {
32452       {
32453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32454       };
32455     } catch (...) {
32456       {
32457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32458       };
32459     }
32460   }
32461
32462   jresult = result;
32463   return jresult;
32464 }
32465
32466
32467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32468   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32469   Dali::WheelEvent::Type arg2 ;
32470
32471   arg1 = (Dali::WheelEvent *)jarg1;
32472   arg2 = (Dali::WheelEvent::Type)jarg2;
32473   if (arg1) (arg1)->type = arg2;
32474 }
32475
32476
32477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32478   int jresult ;
32479   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32480   Dali::WheelEvent::Type result;
32481
32482   arg1 = (Dali::WheelEvent *)jarg1;
32483   result = (Dali::WheelEvent::Type) ((arg1)->type);
32484   jresult = (int)result;
32485   return jresult;
32486 }
32487
32488
32489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32490   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32491   int arg2 ;
32492
32493   arg1 = (Dali::WheelEvent *)jarg1;
32494   arg2 = (int)jarg2;
32495   if (arg1) (arg1)->direction = arg2;
32496 }
32497
32498
32499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32500   int jresult ;
32501   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32502   int result;
32503
32504   arg1 = (Dali::WheelEvent *)jarg1;
32505   result = (int) ((arg1)->direction);
32506   jresult = result;
32507   return jresult;
32508 }
32509
32510
32511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32512   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32513   unsigned int arg2 ;
32514
32515   arg1 = (Dali::WheelEvent *)jarg1;
32516   arg2 = (unsigned int)jarg2;
32517   if (arg1) (arg1)->modifiers = arg2;
32518 }
32519
32520
32521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32522   unsigned int jresult ;
32523   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32524   unsigned int result;
32525
32526   arg1 = (Dali::WheelEvent *)jarg1;
32527   result = (unsigned int) ((arg1)->modifiers);
32528   jresult = result;
32529   return jresult;
32530 }
32531
32532
32533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32534   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32535   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32536
32537   arg1 = (Dali::WheelEvent *)jarg1;
32538   arg2 = (Dali::Vector2 *)jarg2;
32539   if (arg1) (arg1)->point = *arg2;
32540 }
32541
32542
32543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32544   void * jresult ;
32545   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32546   Dali::Vector2 *result = 0 ;
32547
32548   arg1 = (Dali::WheelEvent *)jarg1;
32549   result = (Dali::Vector2 *)& ((arg1)->point);
32550   jresult = (void *)result;
32551   return jresult;
32552 }
32553
32554
32555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32556   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32557   int arg2 ;
32558
32559   arg1 = (Dali::WheelEvent *)jarg1;
32560   arg2 = (int)jarg2;
32561   if (arg1) (arg1)->z = arg2;
32562 }
32563
32564
32565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32566   int jresult ;
32567   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32568   int result;
32569
32570   arg1 = (Dali::WheelEvent *)jarg1;
32571   result = (int) ((arg1)->z);
32572   jresult = result;
32573   return jresult;
32574 }
32575
32576
32577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32578   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32579   unsigned int arg2 ;
32580
32581   arg1 = (Dali::WheelEvent *)jarg1;
32582   arg2 = (unsigned int)jarg2;
32583   if (arg1) (arg1)->timeStamp = arg2;
32584 }
32585
32586
32587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32588   unsigned int jresult ;
32589   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32590   unsigned int result;
32591
32592   arg1 = (Dali::WheelEvent *)jarg1;
32593   result = (unsigned int) ((arg1)->timeStamp);
32594   jresult = result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32599   char * jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   std::string result;
32602
32603   arg1 = (Dali::KeyEvent *)jarg1;
32604   if (!arg1) {
32605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32606     return 0;
32607   }
32608   {
32609     try {
32610       result = arg1->GetDeviceName();
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (Dali::DaliException e) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629
32630   jresult = SWIG_csharp_string_callback((&result)->c_str());
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32635   int jresult ;
32636   Dali::KeyEvent *arg1 = 0 ;
32637   Dali::Device::Class::Type result;
32638
32639   arg1 = (Dali::KeyEvent *)jarg1;
32640   if (!arg1) {
32641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32642     return 0;
32643   }
32644   {
32645     try {
32646       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32662       };
32663     }
32664   }
32665
32666   jresult = (int)result;
32667   return jresult;
32668 }
32669
32670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32671   int jresult ;
32672   Dali::KeyEvent *arg1 = 0 ;
32673   Dali::Device::Subclass::Type result;
32674
32675   arg1 = (Dali::KeyEvent *)jarg1;
32676   if (!arg1) {
32677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32678     return 0;
32679   }
32680   {
32681     try {
32682       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32683     } catch (std::out_of_range& e) {
32684       {
32685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32686       };
32687     } catch (std::exception& e) {
32688       {
32689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32690       };
32691     } catch (Dali::DaliException e) {
32692       {
32693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32698       };
32699     }
32700   }
32701
32702   jresult = (int)result;
32703   return jresult;
32704 }
32705
32706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32707   Dali::Actor arg1 ;
32708   Dali::Actor *argp1 ;
32709
32710   argp1 = (Dali::Actor *)jarg1;
32711   if (!argp1) {
32712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32713     return ;
32714   }
32715   arg1 = *argp1;
32716   {
32717     try {
32718       arg1.Raise();
32719     } catch (std::out_of_range& e) {
32720       {
32721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32722       };
32723     } catch (std::exception& e) {
32724       {
32725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32726       };
32727     } catch (Dali::DaliException e) {
32728       {
32729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32730       };
32731     } catch (...) {
32732       {
32733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32734       };
32735     }
32736   }
32737
32738 }
32739
32740
32741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32742   Dali::Actor arg1 ;
32743   Dali::Actor *argp1 ;
32744
32745   argp1 = (Dali::Actor *)jarg1;
32746   if (!argp1) {
32747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32748     return ;
32749   }
32750   arg1 = *argp1;
32751   {
32752     try {
32753       arg1.Lower();
32754     } catch (std::out_of_range& e) {
32755       {
32756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32757       };
32758     } catch (std::exception& e) {
32759       {
32760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32761       };
32762     } catch (Dali::DaliException e) {
32763       {
32764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32765       };
32766     } catch (...) {
32767       {
32768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32769       };
32770     }
32771   }
32772
32773 }
32774
32775
32776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32777   Dali::Actor arg1 ;
32778   Dali::Actor *argp1 ;
32779
32780   argp1 = (Dali::Actor *)jarg1;
32781   if (!argp1) {
32782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32783     return ;
32784   }
32785   arg1 = *argp1;
32786   {
32787     try {
32788       arg1.RaiseToTop();
32789     } catch (std::out_of_range& e) {
32790       {
32791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32792       };
32793     } catch (std::exception& e) {
32794       {
32795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32796       };
32797     } catch (Dali::DaliException e) {
32798       {
32799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32800       };
32801     } catch (...) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32804       };
32805     }
32806   }
32807
32808 }
32809
32810
32811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32812   Dali::Actor arg1 ;
32813   Dali::Actor *argp1 ;
32814
32815   argp1 = (Dali::Actor *)jarg1;
32816   if (!argp1) {
32817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32818     return ;
32819   }
32820   arg1 = *argp1;
32821   {
32822     try {
32823       arg1.LowerToBottom();
32824     } catch (std::out_of_range& e) {
32825       {
32826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32827       };
32828     } catch (std::exception& e) {
32829       {
32830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32831       };
32832     } catch (Dali::DaliException e) {
32833       {
32834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32835       };
32836     } catch (...) {
32837       {
32838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32839       };
32840     }
32841   }
32842
32843 }
32844
32845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32846   Dali::Actor arg1 ;
32847   Dali::Actor arg2 ;
32848   Dali::Actor *argp1 ;
32849   Dali::Actor *argp2 ;
32850
32851   argp1 = (Dali::Actor *)jarg1;
32852   if (!argp1) {
32853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32854     return ;
32855   }
32856   arg1 = *argp1;
32857   argp2 = (Dali::Actor *)jarg2;
32858   if (!argp2) {
32859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32860     return ;
32861   }
32862   arg2 = *argp2;
32863   {
32864     try {
32865       arg1.RaiseAbove(arg2);
32866     } catch (std::out_of_range& e) {
32867       {
32868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32869       };
32870     } catch (std::exception& e) {
32871       {
32872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32873       };
32874     } catch (Dali::DaliException e) {
32875       {
32876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32877       };
32878     } catch (...) {
32879       {
32880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32881       };
32882     }
32883   }
32884
32885 }
32886
32887
32888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32889   Dali::Actor arg1 ;
32890   Dali::Actor arg2 ;
32891   Dali::Actor *argp1 ;
32892   Dali::Actor *argp2 ;
32893
32894   argp1 = (Dali::Actor *)jarg1;
32895   if (!argp1) {
32896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32897     return ;
32898   }
32899   arg1 = *argp1;
32900   argp2 = (Dali::Actor *)jarg2;
32901   if (!argp2) {
32902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32903     return ;
32904   }
32905   arg2 = *argp2;
32906   {
32907     try {
32908       arg1.LowerBelow(arg2);
32909     } catch (std::out_of_range& e) {
32910       {
32911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32912       };
32913     } catch (std::exception& e) {
32914       {
32915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32916       };
32917     } catch (Dali::DaliException e) {
32918       {
32919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32920       };
32921     } catch (...) {
32922       {
32923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32924       };
32925     }
32926   }
32927
32928 }
32929
32930
32931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32932   void * jresult ;
32933   Dali::Actor arg1 ;
32934   Dali::Actor *argp1 ;
32935   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32936
32937   argp1 = (Dali::Actor *)jarg1;
32938   if (!argp1) {
32939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32940     return 0;
32941   }
32942   arg1 = *argp1;
32943   {
32944     try {
32945       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32946     } catch (std::out_of_range& e) {
32947       {
32948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32949       };
32950     } catch (std::exception& e) {
32951       {
32952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32953       };
32954     } catch (Dali::DaliException e) {
32955       {
32956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32957       };
32958     } catch (...) {
32959       {
32960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32961       };
32962     }
32963   }
32964
32965   jresult = (void *)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32971   void * jresult ;
32972   Dali::Actor *arg1 ;
32973   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32974
32975   arg1 = (Dali::Actor *)jarg1;
32976   {
32977     try {
32978       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32979     } catch (std::out_of_range& e) {
32980       {
32981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32982       };
32983     } catch (std::exception& e) {
32984       {
32985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32986       };
32987     } catch (Dali::DaliException e) {
32988       {
32989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32990       };
32991     } catch (...) {
32992       {
32993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32994       };
32995     }
32996   }
32997
32998   jresult = (void *)result;
32999   return jresult;
33000 }
33001
33002
33003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33004   int jresult ;
33005   int result;
33006
33007   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33008   jresult = (int)result;
33009   return jresult;
33010 }
33011
33012
33013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33014   int jresult ;
33015   int result;
33016
33017   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33018   jresult = (int)result;
33019   return jresult;
33020 }
33021
33022
33023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33024   int jresult ;
33025   int result;
33026
33027   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33028   jresult = (int)result;
33029   return jresult;
33030 }
33031
33032
33033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33034   int jresult ;
33035   int result;
33036
33037   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33038   jresult = (int)result;
33039   return jresult;
33040 }
33041
33042
33043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33044   int jresult ;
33045   int result;
33046
33047   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33048   jresult = (int)result;
33049   return jresult;
33050 }
33051
33052
33053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33054   int jresult ;
33055   int result;
33056
33057   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33058   jresult = (int)result;
33059   return jresult;
33060 }
33061
33062
33063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33064   int jresult ;
33065   int result;
33066
33067   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33068   jresult = (int)result;
33069   return jresult;
33070 }
33071
33072
33073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33074   int jresult ;
33075   int result;
33076
33077   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33078   jresult = (int)result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33084   int jresult ;
33085   int result;
33086
33087   result = (int)Dali::Actor::Property::SIZE;
33088   jresult = (int)result;
33089   return jresult;
33090 }
33091
33092
33093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33094   int jresult ;
33095   int result;
33096
33097   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33098   jresult = (int)result;
33099   return jresult;
33100 }
33101
33102
33103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33104   int jresult ;
33105   int result;
33106
33107   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33108   jresult = (int)result;
33109   return jresult;
33110 }
33111
33112
33113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33114   int jresult ;
33115   int result;
33116
33117   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33118   jresult = (int)result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33124   int jresult ;
33125   int result;
33126
33127   result = (int)Dali::Actor::Property::POSITION;
33128   jresult = (int)result;
33129   return jresult;
33130 }
33131
33132
33133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33134   int jresult ;
33135   int result;
33136
33137   result = (int)Dali::Actor::Property::POSITION_X;
33138   jresult = (int)result;
33139   return jresult;
33140 }
33141
33142
33143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33144   int jresult ;
33145   int result;
33146
33147   result = (int)Dali::Actor::Property::POSITION_Y;
33148   jresult = (int)result;
33149   return jresult;
33150 }
33151
33152
33153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33154   int jresult ;
33155   int result;
33156
33157   result = (int)Dali::Actor::Property::POSITION_Z;
33158   jresult = (int)result;
33159   return jresult;
33160 }
33161
33162
33163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33164   int jresult ;
33165   int result;
33166
33167   result = (int)Dali::Actor::Property::WORLD_POSITION;
33168   jresult = (int)result;
33169   return jresult;
33170 }
33171
33172
33173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33174   int jresult ;
33175   int result;
33176
33177   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33178   jresult = (int)result;
33179   return jresult;
33180 }
33181
33182
33183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33184   int jresult ;
33185   int result;
33186
33187   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33188   jresult = (int)result;
33189   return jresult;
33190 }
33191
33192
33193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33194   int jresult ;
33195   int result;
33196
33197   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33198   jresult = (int)result;
33199   return jresult;
33200 }
33201
33202
33203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33204   int jresult ;
33205   int result;
33206
33207   result = (int)Dali::Actor::Property::ORIENTATION;
33208   jresult = (int)result;
33209   return jresult;
33210 }
33211
33212
33213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33214   int jresult ;
33215   int result;
33216
33217   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33218   jresult = (int)result;
33219   return jresult;
33220 }
33221
33222
33223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33224   int jresult ;
33225   int result;
33226
33227   result = (int)Dali::Actor::Property::SCALE;
33228   jresult = (int)result;
33229   return jresult;
33230 }
33231
33232
33233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33234   int jresult ;
33235   int result;
33236
33237   result = (int)Dali::Actor::Property::SCALE_X;
33238   jresult = (int)result;
33239   return jresult;
33240 }
33241
33242
33243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33244   int jresult ;
33245   int result;
33246
33247   result = (int)Dali::Actor::Property::SCALE_Y;
33248   jresult = (int)result;
33249   return jresult;
33250 }
33251
33252
33253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33254   int jresult ;
33255   int result;
33256
33257   result = (int)Dali::Actor::Property::SCALE_Z;
33258   jresult = (int)result;
33259   return jresult;
33260 }
33261
33262
33263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33264   int jresult ;
33265   int result;
33266
33267   result = (int)Dali::Actor::Property::WORLD_SCALE;
33268   jresult = (int)result;
33269   return jresult;
33270 }
33271
33272
33273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33274   int jresult ;
33275   int result;
33276
33277   result = (int)Dali::Actor::Property::VISIBLE;
33278   jresult = (int)result;
33279   return jresult;
33280 }
33281
33282
33283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33284   int jresult ;
33285   int result;
33286
33287   result = (int)Dali::Actor::Property::COLOR;
33288   jresult = (int)result;
33289   return jresult;
33290 }
33291
33292
33293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33294   int jresult ;
33295   int result;
33296
33297   result = (int)Dali::Actor::Property::COLOR_RED;
33298   jresult = (int)result;
33299   return jresult;
33300 }
33301
33302
33303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33304   int jresult ;
33305   int result;
33306
33307   result = (int)Dali::Actor::Property::COLOR_GREEN;
33308   jresult = (int)result;
33309   return jresult;
33310 }
33311
33312
33313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33314   int jresult ;
33315   int result;
33316
33317   result = (int)Dali::Actor::Property::COLOR_BLUE;
33318   jresult = (int)result;
33319   return jresult;
33320 }
33321
33322
33323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33324   int jresult ;
33325   int result;
33326
33327   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33328   jresult = (int)result;
33329   return jresult;
33330 }
33331
33332
33333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33334   int jresult ;
33335   int result;
33336
33337   result = (int)Dali::Actor::Property::WORLD_COLOR;
33338   jresult = (int)result;
33339   return jresult;
33340 }
33341
33342
33343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33344   int jresult ;
33345   int result;
33346
33347   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33348   jresult = (int)result;
33349   return jresult;
33350 }
33351
33352
33353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33354   int jresult ;
33355   int result;
33356
33357   result = (int)Dali::Actor::Property::NAME;
33358   jresult = (int)result;
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33364   int jresult ;
33365   int result;
33366
33367   result = (int)Dali::Actor::Property::SENSITIVE;
33368   jresult = (int)result;
33369   return jresult;
33370 }
33371
33372
33373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33374   int jresult ;
33375   int result;
33376
33377   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33378   jresult = (int)result;
33379   return jresult;
33380 }
33381
33382
33383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33384   int jresult ;
33385   int result;
33386
33387   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33388   jresult = (int)result;
33389   return jresult;
33390 }
33391
33392
33393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33394   int jresult ;
33395   int result;
33396
33397   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33398   jresult = (int)result;
33399   return jresult;
33400 }
33401
33402
33403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33404   int jresult ;
33405   int result;
33406
33407   result = (int)Dali::Actor::Property::COLOR_MODE;
33408   jresult = (int)result;
33409   return jresult;
33410 }
33411
33412
33413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33414   int jresult ;
33415   int result;
33416
33417   result = (int)Dali::Actor::Property::DRAW_MODE;
33418   jresult = (int)result;
33419   return jresult;
33420 }
33421
33422
33423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33424   int jresult ;
33425   int result;
33426
33427   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33428   jresult = (int)result;
33429   return jresult;
33430 }
33431
33432
33433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33434   int jresult ;
33435   int result;
33436
33437   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33438   jresult = (int)result;
33439   return jresult;
33440 }
33441
33442
33443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33444   int jresult ;
33445   int result;
33446
33447   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33448   jresult = (int)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33454   int jresult ;
33455   int result;
33456
33457   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33458   jresult = (int)result;
33459   return jresult;
33460 }
33461
33462
33463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33464   int jresult ;
33465   int result;
33466
33467   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33468   jresult = (int)result;
33469   return jresult;
33470 }
33471
33472
33473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33474   int jresult ;
33475   int result;
33476
33477   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33478   jresult = (int)result;
33479   return jresult;
33480 }
33481
33482
33483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33484   int jresult ;
33485   int result;
33486
33487   result = (int)Dali::Actor::Property::PADDING;
33488   jresult = (int)result;
33489   return jresult;
33490 }
33491
33492
33493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33494   int jresult ;
33495   int result;
33496
33497   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33498   jresult = (int)result;
33499   return jresult;
33500 }
33501
33502
33503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33504   int jresult ;
33505   int result;
33506
33507   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33508   jresult = (int)result;
33509   return jresult;
33510 }
33511
33512
33513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33514   int jresult ;
33515   int result;
33516
33517   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33518   jresult = (int)result;
33519   return jresult;
33520 }
33521
33522
33523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33524   int jresult ;
33525   int result;
33526
33527   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33528   jresult = (int)result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33534   void * jresult ;
33535   Dali::Actor::Property *result = 0 ;
33536
33537   {
33538     try {
33539       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33540     } catch (std::out_of_range& e) {
33541       {
33542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33543       };
33544     } catch (std::exception& e) {
33545       {
33546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (Dali::DaliException e) {
33549       {
33550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33551       };
33552     } catch (...) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33555       };
33556     }
33557   }
33558
33559   jresult = (void *)result;
33560   return jresult;
33561 }
33562
33563
33564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33565   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33566
33567   arg1 = (Dali::Actor::Property *)jarg1;
33568   {
33569     try {
33570       delete arg1;
33571     } catch (std::out_of_range& e) {
33572       {
33573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33574       };
33575     } catch (std::exception& e) {
33576       {
33577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33578       };
33579     } catch (Dali::DaliException e) {
33580       {
33581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33586       };
33587     }
33588   }
33589
33590 }
33591
33592
33593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33594   void * jresult ;
33595   Dali::Actor *result = 0 ;
33596
33597   {
33598     try {
33599       result = (Dali::Actor *)new Dali::Actor();
33600     } catch (std::out_of_range& e) {
33601       {
33602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33603       };
33604     } catch (std::exception& e) {
33605       {
33606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (Dali::DaliException e) {
33609       {
33610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33611       };
33612     } catch (...) {
33613       {
33614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33615       };
33616     }
33617   }
33618
33619   jresult = (void *)result;
33620   return jresult;
33621 }
33622
33623
33624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33625   void * jresult ;
33626   Dali::Actor result;
33627
33628   {
33629     try {
33630       result = Dali::Actor::New();
33631     } catch (std::out_of_range& e) {
33632       {
33633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33634       };
33635     } catch (std::exception& e) {
33636       {
33637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (Dali::DaliException e) {
33640       {
33641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33642       };
33643     } catch (...) {
33644       {
33645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33646       };
33647     }
33648   }
33649
33650   jresult = new Dali::Actor((const Dali::Actor &)result);
33651   return jresult;
33652 }
33653
33654
33655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33656   void * jresult ;
33657   Dali::BaseHandle arg1 ;
33658   Dali::BaseHandle *argp1 ;
33659   Dali::Actor result;
33660
33661   argp1 = (Dali::BaseHandle *)jarg1;
33662   if (!argp1) {
33663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33664     return 0;
33665   }
33666   arg1 = *argp1;
33667   {
33668     try {
33669       result = Dali::Actor::DownCast(arg1);
33670     } catch (std::out_of_range& e) {
33671       {
33672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33673       };
33674     } catch (std::exception& e) {
33675       {
33676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33677       };
33678     } catch (Dali::DaliException e) {
33679       {
33680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33681       };
33682     } catch (...) {
33683       {
33684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33685       };
33686     }
33687   }
33688
33689   jresult = new Dali::Actor((const Dali::Actor &)result);
33690   return jresult;
33691 }
33692
33693
33694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33696
33697   arg1 = (Dali::Actor *)jarg1;
33698   {
33699     try {
33700       delete arg1;
33701     } catch (std::out_of_range& e) {
33702       {
33703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33704       };
33705     } catch (std::exception& e) {
33706       {
33707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33708       };
33709     } catch (Dali::DaliException e) {
33710       {
33711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33712       };
33713     } catch (...) {
33714       {
33715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33716       };
33717     }
33718   }
33719
33720 }
33721
33722
33723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33724   void * jresult ;
33725   Dali::Actor *arg1 = 0 ;
33726   Dali::Actor *result = 0 ;
33727
33728   arg1 = (Dali::Actor *)jarg1;
33729   if (!arg1) {
33730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33731     return 0;
33732   }
33733   {
33734     try {
33735       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33736     } catch (std::out_of_range& e) {
33737       {
33738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (std::exception& e) {
33741       {
33742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33743       };
33744     } catch (Dali::DaliException e) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33747       };
33748     } catch (...) {
33749       {
33750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33751       };
33752     }
33753   }
33754
33755   jresult = (void *)result;
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33761   void * jresult ;
33762   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33763   Dali::Actor *arg2 = 0 ;
33764   Dali::Actor *result = 0 ;
33765
33766   arg1 = (Dali::Actor *)jarg1;
33767   arg2 = (Dali::Actor *)jarg2;
33768   if (!arg2) {
33769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33770     return 0;
33771   }
33772   {
33773     try {
33774       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33775     } catch (std::out_of_range& e) {
33776       {
33777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33778       };
33779     } catch (std::exception& e) {
33780       {
33781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33782       };
33783     } catch (Dali::DaliException e) {
33784       {
33785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33786       };
33787     } catch (...) {
33788       {
33789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33790       };
33791     }
33792   }
33793
33794   jresult = (void *)result;
33795   return jresult;
33796 }
33797
33798
33799 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33800   char * jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   std::string *result = 0 ;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805   {
33806     try {
33807       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33808       result = (std::string *) &name;
33809     } catch (std::out_of_range& e) {
33810       {
33811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33812       };
33813     } catch (std::exception& e) {
33814       {
33815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33816       };
33817     } catch (Dali::DaliException e) {
33818       {
33819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33820       };
33821     } catch (...) {
33822       {
33823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33824       };
33825     }
33826   }
33827
33828   jresult = SWIG_csharp_string_callback(result->c_str());
33829   return jresult;
33830 }
33831
33832
33833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33835   std::string *arg2 = 0 ;
33836
33837   arg1 = (Dali::Actor *)jarg1;
33838   if (!jarg2) {
33839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33840     return ;
33841   }
33842   std::string arg2_str(jarg2);
33843   arg2 = &arg2_str;
33844   {
33845     try {
33846       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33847     } catch (std::out_of_range& e) {
33848       {
33849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33850       };
33851     } catch (std::exception& e) {
33852       {
33853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33854       };
33855     } catch (Dali::DaliException e) {
33856       {
33857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33858       };
33859     } catch (...) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33862       };
33863     }
33864   }
33865
33866
33867   //argout typemap for const std::string&
33868
33869 }
33870
33871
33872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33873   unsigned int jresult ;
33874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33875   unsigned int result;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878
33879   if(!arg1) {
33880     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33881     return -1;
33882   }
33883
33884   {
33885     try {
33886       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33902       };
33903     }
33904   }
33905
33906   jresult = result;
33907   return jresult;
33908 }
33909
33910
33911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33912   unsigned int jresult ;
33913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33914   bool result;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   {
33918     try {
33919       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33920     } catch (std::out_of_range& e) {
33921       {
33922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33923       };
33924     } catch (std::exception& e) {
33925       {
33926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33927       };
33928     } catch (Dali::DaliException e) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33931       };
33932     } catch (...) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33935       };
33936     }
33937   }
33938
33939   jresult = result;
33940   return jresult;
33941 }
33942
33943
33944 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33945   unsigned int jresult ;
33946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33947   bool result;
33948
33949   arg1 = (Dali::Actor *)jarg1;
33950   {
33951     try {
33952       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33953     } catch (std::out_of_range& e) {
33954       {
33955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33956       };
33957     } catch (std::exception& e) {
33958       {
33959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33960       };
33961     } catch (Dali::DaliException e) {
33962       {
33963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33964       };
33965     } catch (...) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33968       };
33969     }
33970   }
33971
33972   jresult = result;
33973   return jresult;
33974 }
33975
33976
33977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33978   unsigned int jresult ;
33979   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33980   bool result;
33981
33982   arg1 = (Dali::Actor *)jarg1;
33983   {
33984     try {
33985       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = result;
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   Dali::Layer result;
34014
34015   arg1 = (Dali::Actor *)jarg1;
34016   {
34017     try {
34018       result = (arg1)->GetLayer();
34019     } catch (std::out_of_range& e) {
34020       {
34021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34022       };
34023     } catch (std::exception& e) {
34024       {
34025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34026       };
34027     } catch (Dali::DaliException e) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34030       };
34031     } catch (...) {
34032       {
34033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34034       };
34035     }
34036   }
34037
34038   jresult = new Dali::Layer((const Dali::Layer &)result);
34039   return jresult;
34040 }
34041
34042
34043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34044   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34045   Dali::Actor arg2 ;
34046   Dali::Actor *argp2 ;
34047
34048   arg1 = (Dali::Actor *)jarg1;
34049   argp2 = (Dali::Actor *)jarg2;
34050   if (!argp2) {
34051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34052     return ;
34053   }
34054   arg2 = *argp2;
34055   {
34056     try {
34057       (arg1)->Add(arg2);
34058     } catch (std::out_of_range& e) {
34059       {
34060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34061       };
34062     } catch (std::exception& e) {
34063       {
34064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34065       };
34066     } catch (Dali::DaliException e) {
34067       {
34068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34069       };
34070     } catch (...) {
34071       {
34072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34073       };
34074     }
34075   }
34076
34077 }
34078
34079
34080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34082   Dali::Actor arg2 ;
34083   Dali::Actor *argp2 ;
34084
34085   arg1 = (Dali::Actor *)jarg1;
34086   argp2 = (Dali::Actor *)jarg2;
34087   if (!argp2) {
34088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34089     return ;
34090   }
34091   arg2 = *argp2;
34092   {
34093     try {
34094       (arg1)->Remove(arg2);
34095     } catch (std::out_of_range& e) {
34096       {
34097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34098       };
34099     } catch (std::exception& e) {
34100       {
34101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34102       };
34103     } catch (Dali::DaliException e) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34110       };
34111     }
34112   }
34113
34114 }
34115
34116
34117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34119
34120   arg1 = (Dali::Actor *)jarg1;
34121   {
34122     try {
34123       (arg1)->Unparent();
34124     } catch (std::out_of_range& e) {
34125       {
34126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34127       };
34128     } catch (std::exception& e) {
34129       {
34130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34131       };
34132     } catch (Dali::DaliException e) {
34133       {
34134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34135       };
34136     } catch (...) {
34137       {
34138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34139       };
34140     }
34141   }
34142
34143 }
34144
34145
34146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34147   unsigned int jresult ;
34148   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34149   unsigned int result;
34150
34151   arg1 = (Dali::Actor *)jarg1;
34152   {
34153     try {
34154       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34155     } catch (std::out_of_range& e) {
34156       {
34157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (std::exception& e) {
34160       {
34161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34162       };
34163     } catch (Dali::DaliException e) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34166       };
34167     } catch (...) {
34168       {
34169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34170       };
34171     }
34172   }
34173
34174   jresult = result;
34175   return jresult;
34176 }
34177
34178
34179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34180   void * jresult ;
34181   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34182   unsigned int arg2 ;
34183   Dali::Actor result;
34184
34185   arg1 = (Dali::Actor *)jarg1;
34186   arg2 = (unsigned int)jarg2;
34187   {
34188     try {
34189       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34190     } catch (std::out_of_range& e) {
34191       {
34192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34193       };
34194     } catch (std::exception& e) {
34195       {
34196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34197       };
34198     } catch (Dali::DaliException e) {
34199       {
34200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34201       };
34202     } catch (...) {
34203       {
34204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34205       };
34206     }
34207   }
34208
34209   jresult = new Dali::Actor((const Dali::Actor &)result);
34210   return jresult;
34211 }
34212
34213
34214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34215   void * jresult ;
34216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34217   std::string *arg2 = 0 ;
34218   Dali::Actor result;
34219
34220   arg1 = (Dali::Actor *)jarg1;
34221   if (!jarg2) {
34222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34223     return 0;
34224   }
34225   std::string arg2_str(jarg2);
34226   arg2 = &arg2_str;
34227   {
34228     try {
34229       result = (arg1)->FindChildByName((std::string const &)*arg2);
34230     } catch (std::out_of_range& e) {
34231       {
34232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34233       };
34234     } catch (std::exception& e) {
34235       {
34236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34237       };
34238     } catch (Dali::DaliException e) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34241       };
34242     } catch (...) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34245       };
34246     }
34247   }
34248
34249   jresult = new Dali::Actor((const Dali::Actor &)result);
34250
34251   //argout typemap for const std::string&
34252
34253   return jresult;
34254 }
34255
34256
34257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34258   void * jresult ;
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   unsigned int arg2 ;
34261   Dali::Actor result;
34262
34263   arg1 = (Dali::Actor *)jarg1;
34264   arg2 = (unsigned int)jarg2;
34265   {
34266     try {
34267       result = (arg1)->FindChildById(arg2);
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34283       };
34284     }
34285   }
34286
34287   jresult = new Dali::Actor((const Dali::Actor &)result);
34288   return jresult;
34289 }
34290
34291
34292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34293   void * jresult ;
34294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34295   Dali::Actor result;
34296
34297   arg1 = (Dali::Actor *)jarg1;
34298   {
34299     try {
34300       result = ((Dali::Actor const *)arg1)->GetParent();
34301     } catch (std::out_of_range& e) {
34302       {
34303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34304       };
34305     } catch (std::exception& e) {
34306       {
34307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34308       };
34309     } catch (Dali::DaliException e) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34316       };
34317     }
34318   }
34319
34320   jresult = new Dali::Actor((const Dali::Actor &)result);
34321   return jresult;
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   Dali::Vector3 *arg2 = 0 ;
34328
34329   arg1 = (Dali::Actor *)jarg1;
34330   arg2 = (Dali::Vector3 *)jarg2;
34331   if (!arg2) {
34332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34333     return ;
34334   }
34335   {
34336     try {
34337       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34361   void * jresult ;
34362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34363   Dali::Vector3 result;
34364
34365   arg1 = (Dali::Actor *)jarg1;
34366   {
34367     try {
34368       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34369     } catch (std::out_of_range& e) {
34370       {
34371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34372       };
34373     } catch (std::exception& e) {
34374       {
34375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34376       };
34377     } catch (Dali::DaliException e) {
34378       {
34379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34380       };
34381     } catch (...) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34384       };
34385     }
34386   }
34387
34388   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34389   return jresult;
34390 }
34391
34392
34393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34395   Dali::Vector3 *arg2 = 0 ;
34396
34397   arg1 = (Dali::Actor *)jarg1;
34398   arg2 = (Dali::Vector3 *)jarg2;
34399   if (!arg2) {
34400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34401     return ;
34402   }
34403   {
34404     try {
34405       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34406     } catch (std::out_of_range& e) {
34407       {
34408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34409       };
34410     } catch (std::exception& e) {
34411       {
34412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34413       };
34414     } catch (Dali::DaliException e) {
34415       {
34416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34417       };
34418     } catch (...) {
34419       {
34420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34421       };
34422     }
34423   }
34424
34425 }
34426
34427
34428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34429   void * jresult ;
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 result;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   {
34435     try {
34436       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (Dali::DaliException e) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34448       };
34449     } catch (...) {
34450       {
34451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34452       };
34453     }
34454   }
34455
34456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34463   float arg2 ;
34464   float arg3 ;
34465
34466   arg1 = (Dali::Actor *)jarg1;
34467   arg2 = (float)jarg2;
34468   arg3 = (float)jarg3;
34469   {
34470     try {
34471       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34472     } catch (std::out_of_range& e) {
34473       {
34474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34475       };
34476     } catch (std::exception& e) {
34477       {
34478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34479       };
34480     } catch (Dali::DaliException e) {
34481       {
34482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34483       };
34484     } catch (...) {
34485       {
34486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34487       };
34488     }
34489   }
34490
34491 }
34492
34493
34494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34496   float arg2 ;
34497   float arg3 ;
34498   float arg4 ;
34499
34500   arg1 = (Dali::Actor *)jarg1;
34501   arg2 = (float)jarg2;
34502   arg3 = (float)jarg3;
34503   arg4 = (float)jarg4;
34504   {
34505     try {
34506       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34507     } catch (std::out_of_range& e) {
34508       {
34509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34510       };
34511     } catch (std::exception& e) {
34512       {
34513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34514       };
34515     } catch (Dali::DaliException e) {
34516       {
34517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34518       };
34519     } catch (...) {
34520       {
34521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34522       };
34523     }
34524   }
34525
34526 }
34527
34528
34529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34531   Dali::Vector2 *arg2 = 0 ;
34532
34533   arg1 = (Dali::Actor *)jarg1;
34534   arg2 = (Dali::Vector2 *)jarg2;
34535   if (!arg2) {
34536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34537     return ;
34538   }
34539   {
34540     try {
34541       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34542     } catch (std::out_of_range& e) {
34543       {
34544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34545       };
34546     } catch (std::exception& e) {
34547       {
34548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34549       };
34550     } catch (Dali::DaliException e) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34553       };
34554     } catch (...) {
34555       {
34556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34557       };
34558     }
34559   }
34560
34561 }
34562
34563
34564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34565   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34566   Dali::Vector3 *arg2 = 0 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (Dali::Vector3 *)jarg2;
34570   if (!arg2) {
34571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34572     return ;
34573   }
34574   {
34575     try {
34576       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34577     } catch (std::out_of_range& e) {
34578       {
34579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (std::exception& e) {
34582       {
34583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34584       };
34585     } catch (Dali::DaliException e) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34588       };
34589     } catch (...) {
34590       {
34591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34592       };
34593     }
34594   }
34595
34596 }
34597
34598
34599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34600   void * jresult ;
34601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34602   Dali::Vector3 result;
34603
34604   arg1 = (Dali::Actor *)jarg1;
34605   {
34606     try {
34607       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34608     } catch (std::out_of_range& e) {
34609       {
34610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34611       };
34612     } catch (std::exception& e) {
34613       {
34614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34615       };
34616     } catch (Dali::DaliException e) {
34617       {
34618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34619       };
34620     } catch (...) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34623       };
34624     }
34625   }
34626
34627   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34628   return jresult;
34629 }
34630
34631
34632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34633   void * jresult ;
34634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34635   Dali::Vector3 result;
34636
34637   arg1 = (Dali::Actor *)jarg1;
34638   {
34639     try {
34640       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34641     } catch (std::out_of_range& e) {
34642       {
34643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34644       };
34645     } catch (std::exception& e) {
34646       {
34647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34648       };
34649     } catch (Dali::DaliException e) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34652       };
34653     } catch (...) {
34654       {
34655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34656       };
34657     }
34658   }
34659
34660   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34661   return jresult;
34662 }
34663
34664
34665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34666   void * jresult ;
34667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34668   Dali::Vector3 result;
34669
34670   arg1 = (Dali::Actor *)jarg1;
34671   {
34672     try {
34673       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34674     } catch (std::out_of_range& e) {
34675       {
34676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34677       };
34678     } catch (std::exception& e) {
34679       {
34680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34681       };
34682     } catch (Dali::DaliException e) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34685       };
34686     } catch (...) {
34687       {
34688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34689       };
34690     }
34691   }
34692
34693   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34694   return jresult;
34695 }
34696
34697
34698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34700   float arg2 ;
34701   float arg3 ;
34702
34703   arg1 = (Dali::Actor *)jarg1;
34704   arg2 = (float)jarg2;
34705   arg3 = (float)jarg3;
34706   {
34707     try {
34708       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34709     } catch (std::out_of_range& e) {
34710       {
34711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34712       };
34713     } catch (std::exception& e) {
34714       {
34715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34716       };
34717     } catch (Dali::DaliException e) {
34718       {
34719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34720       };
34721     } catch (...) {
34722       {
34723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34724       };
34725     }
34726   }
34727
34728 }
34729
34730
34731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34732   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34733   float arg2 ;
34734   float arg3 ;
34735   float arg4 ;
34736
34737   arg1 = (Dali::Actor *)jarg1;
34738   arg2 = (float)jarg2;
34739   arg3 = (float)jarg3;
34740   arg4 = (float)jarg4;
34741   {
34742     try {
34743       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34744     } catch (std::out_of_range& e) {
34745       {
34746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (std::exception& e) {
34749       {
34750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34751       };
34752     } catch (Dali::DaliException e) {
34753       {
34754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34755       };
34756     } catch (...) {
34757       {
34758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34759       };
34760     }
34761   }
34762
34763 }
34764
34765
34766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34768   Dali::Vector3 *arg2 = 0 ;
34769
34770   arg1 = (Dali::Actor *)jarg1;
34771   arg2 = (Dali::Vector3 *)jarg2;
34772   if (!arg2) {
34773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34774     return ;
34775   }
34776   {
34777     try {
34778       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34779     } catch (std::out_of_range& e) {
34780       {
34781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34782       };
34783     } catch (std::exception& e) {
34784       {
34785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34786       };
34787     } catch (Dali::DaliException e) {
34788       {
34789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34790       };
34791     } catch (...) {
34792       {
34793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34794       };
34795     }
34796   }
34797
34798 }
34799
34800
34801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34802   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34803   float arg2 ;
34804
34805   arg1 = (Dali::Actor *)jarg1;
34806   arg2 = (float)jarg2;
34807   {
34808     try {
34809       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34810     } catch (std::out_of_range& e) {
34811       {
34812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34813       };
34814     } catch (std::exception& e) {
34815       {
34816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34817       };
34818     } catch (Dali::DaliException e) {
34819       {
34820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34821       };
34822     } catch (...) {
34823       {
34824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34825       };
34826     }
34827   }
34828
34829 }
34830
34831
34832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   float arg2 ;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   arg2 = (float)jarg2;
34838   {
34839     try {
34840       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (Dali::DaliException e) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34852       };
34853     } catch (...) {
34854       {
34855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34856       };
34857     }
34858   }
34859
34860 }
34861
34862
34863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34865   float arg2 ;
34866
34867   arg1 = (Dali::Actor *)jarg1;
34868   arg2 = (float)jarg2;
34869   {
34870     try {
34871       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34872     } catch (std::out_of_range& e) {
34873       {
34874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34875       };
34876     } catch (std::exception& e) {
34877       {
34878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34879       };
34880     } catch (Dali::DaliException e) {
34881       {
34882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34883       };
34884     } catch (...) {
34885       {
34886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34887       };
34888     }
34889   }
34890
34891 }
34892
34893
34894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34896   Dali::Vector3 *arg2 = 0 ;
34897
34898   arg1 = (Dali::Actor *)jarg1;
34899   arg2 = (Dali::Vector3 *)jarg2;
34900   if (!arg2) {
34901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34902     return ;
34903   }
34904   {
34905     try {
34906       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34907     } catch (std::out_of_range& e) {
34908       {
34909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (std::exception& e) {
34912       {
34913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34914       };
34915     } catch (Dali::DaliException e) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34918       };
34919     } catch (...) {
34920       {
34921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34922       };
34923     }
34924   }
34925
34926 }
34927
34928
34929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34930   void * jresult ;
34931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34932   Dali::Vector3 result;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   {
34936     try {
34937       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34938     } catch (std::out_of_range& e) {
34939       {
34940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34941       };
34942     } catch (std::exception& e) {
34943       {
34944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34945       };
34946     } catch (Dali::DaliException e) {
34947       {
34948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34949       };
34950     } catch (...) {
34951       {
34952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34953       };
34954     }
34955   }
34956
34957   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34958   return jresult;
34959 }
34960
34961
34962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34963   void * jresult ;
34964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34965   Dali::Vector3 result;
34966
34967   arg1 = (Dali::Actor *)jarg1;
34968   {
34969     try {
34970       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34971     } catch (std::out_of_range& e) {
34972       {
34973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34974       };
34975     } catch (std::exception& e) {
34976       {
34977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34978       };
34979     } catch (Dali::DaliException e) {
34980       {
34981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34982       };
34983     } catch (...) {
34984       {
34985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34986       };
34987     }
34988   }
34989
34990   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34991   return jresult;
34992 }
34993
34994
34995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34996   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34997   bool arg2 ;
34998
34999   arg1 = (Dali::Actor *)jarg1;
35000   arg2 = jarg2 ? true : false;
35001   {
35002     try {
35003       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
35004     } catch (std::out_of_range& e) {
35005       {
35006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35007       };
35008     } catch (std::exception& e) {
35009       {
35010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35011       };
35012     } catch (Dali::DaliException e) {
35013       {
35014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35015       };
35016     } catch (...) {
35017       {
35018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35019       };
35020     }
35021   }
35022
35023 }
35024
35025
35026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35027   unsigned int jresult ;
35028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35029   bool result;
35030
35031   arg1 = (Dali::Actor *)jarg1;
35032   {
35033     try {
35034       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35035     } catch (std::out_of_range& e) {
35036       {
35037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35038       };
35039     } catch (std::exception& e) {
35040       {
35041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35042       };
35043     } catch (Dali::DaliException e) {
35044       {
35045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35046       };
35047     } catch (...) {
35048       {
35049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35050       };
35051     }
35052   }
35053
35054   jresult = result;
35055   return jresult;
35056 }
35057
35058
35059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35061   Dali::Degree *arg2 = 0 ;
35062   Dali::Vector3 *arg3 = 0 ;
35063
35064   arg1 = (Dali::Actor *)jarg1;
35065   arg2 = (Dali::Degree *)jarg2;
35066   if (!arg2) {
35067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35068     return ;
35069   }
35070   arg3 = (Dali::Vector3 *)jarg3;
35071   if (!arg3) {
35072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35073     return ;
35074   }
35075   {
35076     try {
35077       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35078     } catch (std::out_of_range& e) {
35079       {
35080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35081       };
35082     } catch (std::exception& e) {
35083       {
35084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35085       };
35086     } catch (Dali::DaliException e) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35089       };
35090     } catch (...) {
35091       {
35092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35093       };
35094     }
35095   }
35096
35097 }
35098
35099
35100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35101   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35102   Dali::Radian *arg2 = 0 ;
35103   Dali::Vector3 *arg3 = 0 ;
35104
35105   arg1 = (Dali::Actor *)jarg1;
35106   arg2 = (Dali::Radian *)jarg2;
35107   if (!arg2) {
35108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35109     return ;
35110   }
35111   arg3 = (Dali::Vector3 *)jarg3;
35112   if (!arg3) {
35113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35114     return ;
35115   }
35116   {
35117     try {
35118       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35119     } catch (std::out_of_range& e) {
35120       {
35121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35122       };
35123     } catch (std::exception& e) {
35124       {
35125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35126       };
35127     } catch (Dali::DaliException e) {
35128       {
35129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35134       };
35135     }
35136   }
35137
35138 }
35139
35140
35141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35143   Dali::Quaternion *arg2 = 0 ;
35144
35145   arg1 = (Dali::Actor *)jarg1;
35146   arg2 = (Dali::Quaternion *)jarg2;
35147   if (!arg2) {
35148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35149     return ;
35150   }
35151   {
35152     try {
35153       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35154     } catch (std::out_of_range& e) {
35155       {
35156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35157       };
35158     } catch (std::exception& e) {
35159       {
35160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35161       };
35162     } catch (Dali::DaliException e) {
35163       {
35164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35165       };
35166     } catch (...) {
35167       {
35168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35169       };
35170     }
35171   }
35172
35173 }
35174
35175
35176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35178   Dali::Degree *arg2 = 0 ;
35179   Dali::Vector3 *arg3 = 0 ;
35180
35181   arg1 = (Dali::Actor *)jarg1;
35182   arg2 = (Dali::Degree *)jarg2;
35183   if (!arg2) {
35184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35185     return ;
35186   }
35187   arg3 = (Dali::Vector3 *)jarg3;
35188   if (!arg3) {
35189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35190     return ;
35191   }
35192   {
35193     try {
35194       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35195     } catch (std::out_of_range& e) {
35196       {
35197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35198       };
35199     } catch (std::exception& e) {
35200       {
35201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35202       };
35203     } catch (Dali::DaliException e) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35206       };
35207     } catch (...) {
35208       {
35209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35210       };
35211     }
35212   }
35213
35214 }
35215
35216
35217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35219   Dali::Radian *arg2 = 0 ;
35220   Dali::Vector3 *arg3 = 0 ;
35221
35222   arg1 = (Dali::Actor *)jarg1;
35223   arg2 = (Dali::Radian *)jarg2;
35224   if (!arg2) {
35225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35226     return ;
35227   }
35228   arg3 = (Dali::Vector3 *)jarg3;
35229   if (!arg3) {
35230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35231     return ;
35232   }
35233   {
35234     try {
35235       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35236     } catch (std::out_of_range& e) {
35237       {
35238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35239       };
35240     } catch (std::exception& e) {
35241       {
35242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35243       };
35244     } catch (Dali::DaliException e) {
35245       {
35246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35247       };
35248     } catch (...) {
35249       {
35250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35251       };
35252     }
35253   }
35254
35255 }
35256
35257
35258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35260   Dali::Quaternion *arg2 = 0 ;
35261
35262   arg1 = (Dali::Actor *)jarg1;
35263   arg2 = (Dali::Quaternion *)jarg2;
35264   if (!arg2) {
35265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35266     return ;
35267   }
35268   {
35269     try {
35270       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35271     } catch (std::out_of_range& e) {
35272       {
35273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (std::exception& e) {
35276       {
35277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35278       };
35279     } catch (Dali::DaliException e) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35282       };
35283     } catch (...) {
35284       {
35285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35286       };
35287     }
35288   }
35289
35290 }
35291
35292
35293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35294   void * jresult ;
35295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35296   Dali::Quaternion result;
35297
35298   arg1 = (Dali::Actor *)jarg1;
35299   {
35300     try {
35301       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35302     } catch (std::out_of_range& e) {
35303       {
35304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35305       };
35306     } catch (std::exception& e) {
35307       {
35308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35309       };
35310     } catch (Dali::DaliException e) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35313       };
35314     } catch (...) {
35315       {
35316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35317       };
35318     }
35319   }
35320
35321   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35322   return jresult;
35323 }
35324
35325
35326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35328   bool arg2 ;
35329
35330   arg1 = (Dali::Actor *)jarg1;
35331   arg2 = jarg2 ? true : false;
35332   {
35333     try {
35334       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35335     } catch (std::out_of_range& e) {
35336       {
35337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (std::exception& e) {
35340       {
35341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35342       };
35343     } catch (Dali::DaliException e) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35346       };
35347     } catch (...) {
35348       {
35349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35350       };
35351     }
35352   }
35353
35354 }
35355
35356
35357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35358   unsigned int jresult ;
35359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35360   bool result;
35361
35362   arg1 = (Dali::Actor *)jarg1;
35363   {
35364     try {
35365       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35366     } catch (std::out_of_range& e) {
35367       {
35368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35369       };
35370     } catch (std::exception& e) {
35371       {
35372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35373       };
35374     } catch (Dali::DaliException e) {
35375       {
35376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35381       };
35382     }
35383   }
35384
35385   jresult = result;
35386   return jresult;
35387 }
35388
35389
35390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35391   void * jresult ;
35392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35393   Dali::Quaternion result;
35394
35395   arg1 = (Dali::Actor *)jarg1;
35396   {
35397     try {
35398       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35399     } catch (std::out_of_range& e) {
35400       {
35401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35402       };
35403     } catch (std::exception& e) {
35404       {
35405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35406       };
35407     } catch (Dali::DaliException e) {
35408       {
35409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35410       };
35411     } catch (...) {
35412       {
35413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35414       };
35415     }
35416   }
35417
35418   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35419   return jresult;
35420 }
35421
35422
35423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35425   float arg2 ;
35426
35427   arg1 = (Dali::Actor *)jarg1;
35428   arg2 = (float)jarg2;
35429   {
35430     try {
35431       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35432     } catch (std::out_of_range& e) {
35433       {
35434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35435       };
35436     } catch (std::exception& e) {
35437       {
35438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35439       };
35440     } catch (Dali::DaliException e) {
35441       {
35442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35443       };
35444     } catch (...) {
35445       {
35446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35447       };
35448     }
35449   }
35450
35451 }
35452
35453
35454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35456   float arg2 ;
35457   float arg3 ;
35458   float arg4 ;
35459
35460   arg1 = (Dali::Actor *)jarg1;
35461   arg2 = (float)jarg2;
35462   arg3 = (float)jarg3;
35463   arg4 = (float)jarg4;
35464   {
35465     try {
35466       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35467     } catch (std::out_of_range& e) {
35468       {
35469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35470       };
35471     } catch (std::exception& e) {
35472       {
35473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35474       };
35475     } catch (Dali::DaliException e) {
35476       {
35477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35478       };
35479     } catch (...) {
35480       {
35481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35482       };
35483     }
35484   }
35485
35486 }
35487
35488
35489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35491   Dali::Vector3 *arg2 = 0 ;
35492
35493   arg1 = (Dali::Actor *)jarg1;
35494   arg2 = (Dali::Vector3 *)jarg2;
35495   if (!arg2) {
35496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35497     return ;
35498   }
35499   {
35500     try {
35501       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35502     } catch (std::out_of_range& e) {
35503       {
35504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35505       };
35506     } catch (std::exception& e) {
35507       {
35508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35509       };
35510     } catch (Dali::DaliException e) {
35511       {
35512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35513       };
35514     } catch (...) {
35515       {
35516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35517       };
35518     }
35519   }
35520
35521 }
35522
35523
35524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35525   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35526   Dali::Vector3 *arg2 = 0 ;
35527
35528   arg1 = (Dali::Actor *)jarg1;
35529   arg2 = (Dali::Vector3 *)jarg2;
35530   if (!arg2) {
35531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35532     return ;
35533   }
35534   {
35535     try {
35536       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35537     } catch (std::out_of_range& e) {
35538       {
35539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35540       };
35541     } catch (std::exception& e) {
35542       {
35543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35544       };
35545     } catch (Dali::DaliException e) {
35546       {
35547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35548       };
35549     } catch (...) {
35550       {
35551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35552       };
35553     }
35554   }
35555
35556 }
35557
35558
35559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35560   void * jresult ;
35561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35562   Dali::Vector3 result;
35563
35564   arg1 = (Dali::Actor *)jarg1;
35565   {
35566     try {
35567       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35568     } catch (std::out_of_range& e) {
35569       {
35570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35571       };
35572     } catch (std::exception& e) {
35573       {
35574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35575       };
35576     } catch (Dali::DaliException e) {
35577       {
35578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35579       };
35580     } catch (...) {
35581       {
35582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35583       };
35584     }
35585   }
35586
35587   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35588   return jresult;
35589 }
35590
35591
35592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35593   void * jresult ;
35594   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35595   Dali::Vector3 result;
35596
35597   arg1 = (Dali::Actor *)jarg1;
35598   {
35599     try {
35600       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35608       };
35609     } catch (Dali::DaliException e) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35612       };
35613     } catch (...) {
35614       {
35615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35616       };
35617     }
35618   }
35619
35620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35621   return jresult;
35622 }
35623
35624
35625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35626   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35627   bool arg2 ;
35628
35629   arg1 = (Dali::Actor *)jarg1;
35630   arg2 = jarg2 ? true : false;
35631   {
35632     try {
35633       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35634     } catch (std::out_of_range& e) {
35635       {
35636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35637       };
35638     } catch (std::exception& e) {
35639       {
35640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35641       };
35642     } catch (Dali::DaliException e) {
35643       {
35644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35645       };
35646     } catch (...) {
35647       {
35648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35649       };
35650     }
35651   }
35652
35653 }
35654
35655
35656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35657   unsigned int jresult ;
35658   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35659   bool result;
35660
35661   arg1 = (Dali::Actor *)jarg1;
35662   {
35663     try {
35664       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35665     } catch (std::out_of_range& e) {
35666       {
35667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35668       };
35669     } catch (std::exception& e) {
35670       {
35671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35672       };
35673     } catch (Dali::DaliException e) {
35674       {
35675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35676       };
35677     } catch (...) {
35678       {
35679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35680       };
35681     }
35682   }
35683
35684   jresult = result;
35685   return jresult;
35686 }
35687
35688
35689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35690   void * jresult ;
35691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35692   Dali::Matrix result;
35693
35694   arg1 = (Dali::Actor *)jarg1;
35695   {
35696     try {
35697       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35698     } catch (std::out_of_range& e) {
35699       {
35700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35701       };
35702     } catch (std::exception& e) {
35703       {
35704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35705       };
35706     } catch (Dali::DaliException e) {
35707       {
35708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35709       };
35710     } catch (...) {
35711       {
35712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35713       };
35714     }
35715   }
35716
35717   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35718   return jresult;
35719 }
35720
35721
35722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35724   bool arg2 ;
35725
35726   arg1 = (Dali::Actor *)jarg1;
35727   arg2 = jarg2 ? true : false;
35728   {
35729     try {
35730       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35731     } catch (std::out_of_range& e) {
35732       {
35733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35734       };
35735     } catch (std::exception& e) {
35736       {
35737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35738       };
35739     } catch (Dali::DaliException e) {
35740       {
35741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35742       };
35743     } catch (...) {
35744       {
35745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35746       };
35747     }
35748   }
35749
35750 }
35751
35752
35753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35754   unsigned int jresult ;
35755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35756   bool result;
35757
35758   arg1 = (Dali::Actor *)jarg1;
35759   {
35760     try {
35761       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35762     } catch (std::out_of_range& e) {
35763       {
35764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35765       };
35766     } catch (std::exception& e) {
35767       {
35768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35769       };
35770     } catch (Dali::DaliException e) {
35771       {
35772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35773       };
35774     } catch (...) {
35775       {
35776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35777       };
35778     }
35779   }
35780
35781   jresult = result;
35782   return jresult;
35783 }
35784
35785
35786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35787   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35788   float arg2 ;
35789
35790   arg1 = (Dali::Actor *)jarg1;
35791   arg2 = (float)jarg2;
35792   {
35793     try {
35794       (arg1)->SetProperty( DevelActor::Property::OPACITY,arg2);
35795     } catch (std::out_of_range& e) {
35796       {
35797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35798       };
35799     } catch (std::exception& e) {
35800       {
35801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35802       };
35803     } catch (Dali::DaliException e) {
35804       {
35805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35806       };
35807     } catch (...) {
35808       {
35809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35810       };
35811     }
35812   }
35813
35814 }
35815
35816
35817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35818   float jresult ;
35819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35820   float result;
35821
35822   arg1 = (Dali::Actor *)jarg1;
35823   {
35824     try {
35825       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( DevelActor::Property::OPACITY );
35826     } catch (std::out_of_range& e) {
35827       {
35828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35829       };
35830     } catch (std::exception& e) {
35831       {
35832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35833       };
35834     } catch (Dali::DaliException e) {
35835       {
35836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35841       };
35842     }
35843   }
35844
35845   jresult = result;
35846   return jresult;
35847 }
35848
35849
35850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35851   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35852   Dali::Vector4 *arg2 = 0 ;
35853
35854   arg1 = (Dali::Actor *)jarg1;
35855   arg2 = (Dali::Vector4 *)jarg2;
35856   if (!arg2) {
35857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35858     return ;
35859   }
35860   {
35861     try {
35862       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35863     } catch (std::out_of_range& e) {
35864       {
35865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35866       };
35867     } catch (std::exception& e) {
35868       {
35869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35870       };
35871     } catch (Dali::DaliException e) {
35872       {
35873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35874       };
35875     } catch (...) {
35876       {
35877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35878       };
35879     }
35880   }
35881
35882 }
35883
35884
35885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35886   void * jresult ;
35887   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35888   Dali::Vector4 result;
35889
35890   arg1 = (Dali::Actor *)jarg1;
35891   {
35892     try {
35893       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35894     } catch (std::out_of_range& e) {
35895       {
35896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35897       };
35898     } catch (std::exception& e) {
35899       {
35900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35901       };
35902     } catch (Dali::DaliException e) {
35903       {
35904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35905       };
35906     } catch (...) {
35907       {
35908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35909       };
35910     }
35911   }
35912
35913   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35914   return jresult;
35915 }
35916
35917
35918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35920   Dali::ColorMode arg2 ;
35921
35922   arg1 = (Dali::Actor *)jarg1;
35923   arg2 = (Dali::ColorMode)jarg2;
35924   {
35925     try {
35926       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35927     } catch (std::out_of_range& e) {
35928       {
35929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35930       };
35931     } catch (std::exception& e) {
35932       {
35933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35934       };
35935     } catch (Dali::DaliException e) {
35936       {
35937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35938       };
35939     } catch (...) {
35940       {
35941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35942       };
35943     }
35944   }
35945
35946 }
35947
35948
35949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35950   int jresult ;
35951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35952   Dali::ColorMode result;
35953
35954   arg1 = (Dali::Actor *)jarg1;
35955   {
35956     try {
35957       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35958     } catch (std::out_of_range& e) {
35959       {
35960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35961       };
35962     } catch (std::exception& e) {
35963       {
35964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35965       };
35966     } catch (Dali::DaliException e) {
35967       {
35968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35969       };
35970     } catch (...) {
35971       {
35972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35973       };
35974     }
35975   }
35976
35977   jresult = (int)result;
35978   return jresult;
35979 }
35980
35981
35982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35983   void * jresult ;
35984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35985   Dali::Vector4 result;
35986
35987   arg1 = (Dali::Actor *)jarg1;
35988   {
35989     try {
35990       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35991     } catch (std::out_of_range& e) {
35992       {
35993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35994       };
35995     } catch (std::exception& e) {
35996       {
35997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35998       };
35999     } catch (Dali::DaliException e) {
36000       {
36001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36002       };
36003     } catch (...) {
36004       {
36005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36006       };
36007     }
36008   }
36009
36010   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36011   return jresult;
36012 }
36013
36014
36015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36017   Dali::DrawMode::Type arg2 ;
36018
36019   arg1 = (Dali::Actor *)jarg1;
36020   arg2 = (Dali::DrawMode::Type)jarg2;
36021   {
36022     try {
36023       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
36024     } catch (std::out_of_range& e) {
36025       {
36026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36027       };
36028     } catch (std::exception& e) {
36029       {
36030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36031       };
36032     } catch (Dali::DaliException e) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36035       };
36036     } catch (...) {
36037       {
36038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36039       };
36040     }
36041   }
36042
36043 }
36044
36045
36046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36047   int jresult ;
36048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36049   Dali::DrawMode::Type result;
36050
36051   arg1 = (Dali::Actor *)jarg1;
36052   {
36053     try {
36054       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36055     } catch (std::out_of_range& e) {
36056       {
36057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36058       };
36059     } catch (std::exception& e) {
36060       {
36061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36062       };
36063     } catch (Dali::DaliException e) {
36064       {
36065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36066       };
36067     } catch (...) {
36068       {
36069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36070       };
36071     }
36072   }
36073
36074   jresult = (int)result;
36075   return jresult;
36076 }
36077
36078
36079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36081   bool arg2 ;
36082
36083   arg1 = (Dali::Actor *)jarg1;
36084   arg2 = jarg2 ? true : false;
36085   {
36086     try {
36087       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36088     } catch (std::out_of_range& e) {
36089       {
36090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36091       };
36092     } catch (std::exception& e) {
36093       {
36094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36095       };
36096     } catch (Dali::DaliException e) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36099       };
36100     } catch (...) {
36101       {
36102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36103       };
36104     }
36105   }
36106
36107 }
36108
36109
36110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36111   unsigned int jresult ;
36112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36113   bool result;
36114
36115   arg1 = (Dali::Actor *)jarg1;
36116   {
36117     try {
36118       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36134       };
36135     }
36136   }
36137
36138   jresult = result;
36139   return jresult;
36140 }
36141
36142
36143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36144   unsigned int jresult ;
36145   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36146   float *arg2 = 0 ;
36147   float *arg3 = 0 ;
36148   float arg4 ;
36149   float arg5 ;
36150   bool result;
36151
36152   arg1 = (Dali::Actor *)jarg1;
36153   arg2 = (float *)jarg2;
36154   arg3 = (float *)jarg3;
36155   arg4 = (float)jarg4;
36156   arg5 = (float)jarg5;
36157   {
36158     try {
36159       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36160     } catch (std::out_of_range& e) {
36161       {
36162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36163       };
36164     } catch (std::exception& e) {
36165       {
36166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36167       };
36168     } catch (Dali::DaliException e) {
36169       {
36170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36171       };
36172     } catch (...) {
36173       {
36174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36175       };
36176     }
36177   }
36178
36179   jresult = result;
36180   return jresult;
36181 }
36182
36183
36184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36186   bool arg2 ;
36187
36188   arg1 = (Dali::Actor *)jarg1;
36189   arg2 = jarg2 ? true : false;
36190   {
36191     try {
36192       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36193     } catch (std::out_of_range& e) {
36194       {
36195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36196       };
36197     } catch (std::exception& e) {
36198       {
36199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36200       };
36201     } catch (Dali::DaliException e) {
36202       {
36203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36204       };
36205     } catch (...) {
36206       {
36207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36208       };
36209     }
36210   }
36211
36212 }
36213
36214
36215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36216   unsigned int jresult ;
36217   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36218   bool result;
36219
36220   arg1 = (Dali::Actor *)jarg1;
36221   {
36222     try {
36223       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36224     } catch (std::out_of_range& e) {
36225       {
36226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36227       };
36228     } catch (std::exception& e) {
36229       {
36230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36231       };
36232     } catch (Dali::DaliException e) {
36233       {
36234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36235       };
36236     } catch (...) {
36237       {
36238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36239       };
36240     }
36241   }
36242
36243   jresult = result;
36244   return jresult;
36245 }
36246
36247
36248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36249   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36250   bool arg2 ;
36251
36252   arg1 = (Dali::Actor *)jarg1;
36253   arg2 = jarg2 ? true : false;
36254   {
36255     try {
36256       (arg1)->SetKeyboardFocusable(arg2);
36257     } catch (std::out_of_range& e) {
36258       {
36259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36260       };
36261     } catch (std::exception& e) {
36262       {
36263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36264       };
36265     } catch (Dali::DaliException e) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36268       };
36269     } catch (...) {
36270       {
36271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36272       };
36273     }
36274   }
36275
36276 }
36277
36278
36279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36280   unsigned int jresult ;
36281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36282   bool result;
36283
36284   arg1 = (Dali::Actor *)jarg1;
36285   {
36286     try {
36287       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36288     } catch (std::out_of_range& e) {
36289       {
36290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (std::exception& e) {
36293       {
36294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36295       };
36296     } catch (Dali::DaliException e) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36299       };
36300     } catch (...) {
36301       {
36302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36303       };
36304     }
36305   }
36306
36307   jresult = result;
36308   return jresult;
36309 }
36310
36311
36312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36314   Dali::ResizePolicy::Type arg2 ;
36315   Dali::Dimension::Type arg3 ;
36316
36317   arg1 = (Dali::Actor *)jarg1;
36318   arg2 = (Dali::ResizePolicy::Type)jarg2;
36319   arg3 = (Dali::Dimension::Type)jarg3;
36320   {
36321     try {
36322       (arg1)->SetResizePolicy(arg2,arg3);
36323     } catch (std::out_of_range& e) {
36324       {
36325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36326       };
36327     } catch (std::exception& e) {
36328       {
36329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36330       };
36331     } catch (Dali::DaliException e) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36334       };
36335     } catch (...) {
36336       {
36337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36338       };
36339     }
36340   }
36341
36342 }
36343
36344
36345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36346   int jresult ;
36347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36348   Dali::Dimension::Type arg2 ;
36349   Dali::ResizePolicy::Type result;
36350
36351   arg1 = (Dali::Actor *)jarg1;
36352   arg2 = (Dali::Dimension::Type)jarg2;
36353   {
36354     try {
36355       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36356     } catch (std::out_of_range& e) {
36357       {
36358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (std::exception& e) {
36361       {
36362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36363       };
36364     } catch (Dali::DaliException e) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36367       };
36368     } catch (...) {
36369       {
36370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36371       };
36372     }
36373   }
36374
36375   jresult = (int)result;
36376   return jresult;
36377 }
36378
36379
36380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36381   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36382   Dali::SizeScalePolicy::Type arg2 ;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36386   {
36387     try {
36388       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36404       };
36405     }
36406   }
36407
36408 }
36409
36410
36411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36412   int jresult ;
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::SizeScalePolicy::Type result;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   {
36418     try {
36419       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36420     } catch (std::out_of_range& e) {
36421       {
36422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36423       };
36424     } catch (std::exception& e) {
36425       {
36426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36427       };
36428     } catch (Dali::DaliException e) {
36429       {
36430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36431       };
36432     } catch (...) {
36433       {
36434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36435       };
36436     }
36437   }
36438
36439   jresult = (int)result;
36440   return jresult;
36441 }
36442
36443
36444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36445   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36446   Dali::Vector3 *arg2 = 0 ;
36447
36448   arg1 = (Dali::Actor *)jarg1;
36449   arg2 = (Dali::Vector3 *)jarg2;
36450   if (!arg2) {
36451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36452     return ;
36453   }
36454   {
36455     try {
36456       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36457     } catch (std::out_of_range& e) {
36458       {
36459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36460       };
36461     } catch (std::exception& e) {
36462       {
36463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (Dali::DaliException e) {
36466       {
36467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36468       };
36469     } catch (...) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36472       };
36473     }
36474   }
36475
36476 }
36477
36478
36479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36480   void * jresult ;
36481   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36482   Dali::Vector3 result;
36483
36484   arg1 = (Dali::Actor *)jarg1;
36485   {
36486     try {
36487       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36488     } catch (std::out_of_range& e) {
36489       {
36490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36491       };
36492     } catch (std::exception& e) {
36493       {
36494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36495       };
36496     } catch (Dali::DaliException e) {
36497       {
36498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36499       };
36500     } catch (...) {
36501       {
36502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36503       };
36504     }
36505   }
36506
36507   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36508   return jresult;
36509 }
36510
36511
36512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36513   float jresult ;
36514   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36515   float arg2 ;
36516   float result;
36517
36518   arg1 = (Dali::Actor *)jarg1;
36519   arg2 = (float)jarg2;
36520   {
36521     try {
36522       result = (float)(arg1)->GetHeightForWidth(arg2);
36523     } catch (std::out_of_range& e) {
36524       {
36525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36526       };
36527     } catch (std::exception& e) {
36528       {
36529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (Dali::DaliException e) {
36532       {
36533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36534       };
36535     } catch (...) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36538       };
36539     }
36540   }
36541
36542   jresult = result;
36543   return jresult;
36544 }
36545
36546
36547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36548   float jresult ;
36549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36550   float arg2 ;
36551   float result;
36552
36553   arg1 = (Dali::Actor *)jarg1;
36554   arg2 = (float)jarg2;
36555   {
36556     try {
36557       result = (float)(arg1)->GetWidthForHeight(arg2);
36558     } catch (std::out_of_range& e) {
36559       {
36560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36561       };
36562     } catch (std::exception& e) {
36563       {
36564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (Dali::DaliException e) {
36567       {
36568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36569       };
36570     } catch (...) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36573       };
36574     }
36575   }
36576
36577   jresult = result;
36578   return jresult;
36579 }
36580
36581
36582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36583   float jresult ;
36584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36585   Dali::Dimension::Type arg2 ;
36586   float result;
36587
36588   arg1 = (Dali::Actor *)jarg1;
36589   arg2 = (Dali::Dimension::Type)jarg2;
36590   {
36591     try {
36592       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36593     } catch (std::out_of_range& e) {
36594       {
36595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36596       };
36597     } catch (std::exception& e) {
36598       {
36599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36600       };
36601     } catch (Dali::DaliException e) {
36602       {
36603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36604       };
36605     } catch (...) {
36606       {
36607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36608       };
36609     }
36610   }
36611
36612   jresult = result;
36613   return jresult;
36614 }
36615
36616
36617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36619   Dali::Padding *arg2 = 0 ;
36620
36621   arg1 = (Dali::Actor *)jarg1;
36622   arg2 = (Dali::Padding *)jarg2;
36623   if (!arg2) {
36624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36625     return ;
36626   }
36627   {
36628     try {
36629       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36645       };
36646     }
36647   }
36648
36649 }
36650
36651
36652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36654   Dali::Padding *arg2 = 0 ;
36655
36656   arg1 = (Dali::Actor *)jarg1;
36657   arg2 = (Dali::Padding *)jarg2;
36658   if (!arg2) {
36659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36660     return ;
36661   }
36662   {
36663     try {
36664       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36665     } catch (std::out_of_range& e) {
36666       {
36667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36668       };
36669     } catch (std::exception& e) {
36670       {
36671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36672       };
36673     } catch (Dali::DaliException e) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36676       };
36677     } catch (...) {
36678       {
36679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36680       };
36681     }
36682   }
36683
36684 }
36685
36686
36687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36689   Dali::Vector2 *arg2 = 0 ;
36690
36691   arg1 = (Dali::Actor *)jarg1;
36692   arg2 = (Dali::Vector2 *)jarg2;
36693   if (!arg2) {
36694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36695     return ;
36696   }
36697   {
36698     try {
36699       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36700     } catch (std::out_of_range& e) {
36701       {
36702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36703       };
36704     } catch (std::exception& e) {
36705       {
36706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36707       };
36708     } catch (Dali::DaliException e) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36711       };
36712     } catch (...) {
36713       {
36714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36715       };
36716     }
36717   }
36718
36719 }
36720
36721
36722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36723   void * jresult ;
36724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36725   Dali::Vector2 result;
36726
36727   arg1 = (Dali::Actor *)jarg1;
36728   {
36729     try {
36730       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36731     } catch (std::out_of_range& e) {
36732       {
36733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36734       };
36735     } catch (std::exception& e) {
36736       {
36737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36738       };
36739     } catch (Dali::DaliException e) {
36740       {
36741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36742       };
36743     } catch (...) {
36744       {
36745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36746       };
36747     }
36748   }
36749
36750   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36751   return jresult;
36752 }
36753
36754
36755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36757   Dali::Vector2 *arg2 = 0 ;
36758
36759   arg1 = (Dali::Actor *)jarg1;
36760   arg2 = (Dali::Vector2 *)jarg2;
36761   if (!arg2) {
36762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36763     return ;
36764   }
36765   {
36766     try {
36767       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36768     } catch (std::out_of_range& e) {
36769       {
36770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36771       };
36772     } catch (std::exception& e) {
36773       {
36774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36775       };
36776     } catch (Dali::DaliException e) {
36777       {
36778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36779       };
36780     } catch (...) {
36781       {
36782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36783       };
36784     }
36785   }
36786
36787 }
36788
36789
36790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36791   void * jresult ;
36792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36793   Dali::Vector2 result;
36794
36795   arg1 = (Dali::Actor *)jarg1;
36796   {
36797     try {
36798       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36799     } catch (std::out_of_range& e) {
36800       {
36801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (std::exception& e) {
36804       {
36805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36806       };
36807     } catch (Dali::DaliException e) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36810       };
36811     } catch (...) {
36812       {
36813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36814       };
36815     }
36816   }
36817
36818   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36819   return jresult;
36820 }
36821
36822
36823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36824   int jresult ;
36825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36826   int result;
36827
36828   arg1 = (Dali::Actor *)jarg1;
36829   {
36830     try {
36831       result = (int)(arg1)->GetHierarchyDepth();
36832       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36833     } catch (std::out_of_range& e) {
36834       {
36835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36836       };
36837     } catch (std::exception& e) {
36838       {
36839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36840       };
36841     } catch (Dali::DaliException e) {
36842       {
36843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36844       };
36845     } catch (...) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36848       };
36849     }
36850   }
36851
36852   jresult = result;
36853   return jresult;
36854 }
36855
36856
36857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36858   unsigned int jresult ;
36859   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36860   Dali::Renderer *arg2 = 0 ;
36861   unsigned int result;
36862
36863   arg1 = (Dali::Actor *)jarg1;
36864   arg2 = (Dali::Renderer *)jarg2;
36865   if (!arg2) {
36866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36867     return 0;
36868   }
36869   {
36870     try {
36871       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36872     } catch (std::out_of_range& e) {
36873       {
36874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (std::exception& e) {
36877       {
36878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36879       };
36880     } catch (Dali::DaliException e) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36883       };
36884     } catch (...) {
36885       {
36886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36887       };
36888     }
36889   }
36890
36891   jresult = result;
36892   return jresult;
36893 }
36894
36895
36896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36897   unsigned int jresult ;
36898   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36899   unsigned int result;
36900
36901   arg1 = (Dali::Actor *)jarg1;
36902   {
36903     try {
36904       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36905     } catch (std::out_of_range& e) {
36906       {
36907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (std::exception& e) {
36910       {
36911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (Dali::DaliException e) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36920       };
36921     }
36922   }
36923
36924   jresult = result;
36925   return jresult;
36926 }
36927
36928
36929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36930   void * jresult ;
36931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36932   unsigned int arg2 ;
36933   Dali::Renderer result;
36934
36935   arg1 = (Dali::Actor *)jarg1;
36936   arg2 = (unsigned int)jarg2;
36937   {
36938     try {
36939       result = (arg1)->GetRendererAt(arg2);
36940     } catch (std::out_of_range& e) {
36941       {
36942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (std::exception& e) {
36945       {
36946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36947       };
36948     } catch (Dali::DaliException e) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36951       };
36952     } catch (...) {
36953       {
36954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36955       };
36956     }
36957   }
36958
36959   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36960   return jresult;
36961 }
36962
36963
36964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36966   Dali::Renderer *arg2 = 0 ;
36967
36968   arg1 = (Dali::Actor *)jarg1;
36969   arg2 = (Dali::Renderer *)jarg2;
36970   if (!arg2) {
36971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36972     return ;
36973   }
36974   {
36975     try {
36976       (arg1)->RemoveRenderer(*arg2);
36977     } catch (std::out_of_range& e) {
36978       {
36979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36980       };
36981     } catch (std::exception& e) {
36982       {
36983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36984       };
36985     } catch (Dali::DaliException e) {
36986       {
36987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36988       };
36989     } catch (...) {
36990       {
36991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36992       };
36993     }
36994   }
36995
36996 }
36997
36998
36999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
37000   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37001   unsigned int arg2 ;
37002
37003   arg1 = (Dali::Actor *)jarg1;
37004   arg2 = (unsigned int)jarg2;
37005   {
37006     try {
37007       (arg1)->RemoveRenderer(arg2);
37008     } catch (std::out_of_range& e) {
37009       {
37010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37011       };
37012     } catch (std::exception& e) {
37013       {
37014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37015       };
37016     } catch (Dali::DaliException e) {
37017       {
37018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37019       };
37020     } catch (...) {
37021       {
37022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37023       };
37024     }
37025   }
37026
37027 }
37028
37029
37030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37031   void * jresult ;
37032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37033   Dali::Actor::TouchSignalType *result = 0 ;
37034
37035   arg1 = (Dali::Actor *)jarg1;
37036   {
37037     try {
37038       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37039     } catch (std::out_of_range& e) {
37040       {
37041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (std::exception& e) {
37044       {
37045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (Dali::DaliException e) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37050       };
37051     } catch (...) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37054       };
37055     }
37056   }
37057
37058   jresult = (void *)result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37064   void * jresult ;
37065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37066   Dali::Actor::TouchDataSignalType *result = 0 ;
37067
37068   arg1 = (Dali::Actor *)jarg1;
37069   {
37070     try {
37071       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37072     } catch (std::out_of_range& e) {
37073       {
37074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (std::exception& e) {
37077       {
37078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37079       };
37080     } catch (Dali::DaliException e) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37083       };
37084     } catch (...) {
37085       {
37086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37087       };
37088     }
37089   }
37090
37091   jresult = (void *)result;
37092   return jresult;
37093 }
37094
37095
37096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37097   void * jresult ;
37098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37099   Dali::Actor::HoverSignalType *result = 0 ;
37100
37101   arg1 = (Dali::Actor *)jarg1;
37102   {
37103     try {
37104       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37105     } catch (std::out_of_range& e) {
37106       {
37107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (std::exception& e) {
37110       {
37111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37112       };
37113     } catch (Dali::DaliException e) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37116       };
37117     } catch (...) {
37118       {
37119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37120       };
37121     }
37122   }
37123
37124   jresult = (void *)result;
37125   return jresult;
37126 }
37127
37128
37129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37130   void * jresult ;
37131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37132   Dali::Actor::WheelEventSignalType *result = 0 ;
37133
37134   arg1 = (Dali::Actor *)jarg1;
37135   {
37136     try {
37137       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37138     } catch (std::out_of_range& e) {
37139       {
37140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (std::exception& e) {
37143       {
37144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37145       };
37146     } catch (Dali::DaliException e) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37149       };
37150     } catch (...) {
37151       {
37152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37153       };
37154     }
37155   }
37156
37157   jresult = (void *)result;
37158   return jresult;
37159 }
37160
37161
37162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37163   void * jresult ;
37164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37165   Dali::Actor::OnStageSignalType *result = 0 ;
37166
37167   arg1 = (Dali::Actor *)jarg1;
37168   {
37169     try {
37170       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37171     } catch (std::out_of_range& e) {
37172       {
37173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37174       };
37175     } catch (std::exception& e) {
37176       {
37177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37178       };
37179     } catch (Dali::DaliException e) {
37180       {
37181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37182       };
37183     } catch (...) {
37184       {
37185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37186       };
37187     }
37188   }
37189
37190   jresult = (void *)result;
37191   return jresult;
37192 }
37193
37194
37195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37196   void * jresult ;
37197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37198   Dali::Actor::OffStageSignalType *result = 0 ;
37199
37200   arg1 = (Dali::Actor *)jarg1;
37201   {
37202     try {
37203       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37204     } catch (std::out_of_range& e) {
37205       {
37206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37207       };
37208     } catch (std::exception& e) {
37209       {
37210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37211       };
37212     } catch (Dali::DaliException e) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37215       };
37216     } catch (...) {
37217       {
37218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37219       };
37220     }
37221   }
37222
37223   jresult = (void *)result;
37224   return jresult;
37225 }
37226
37227
37228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37229   void * jresult ;
37230   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37231   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37232
37233   arg1 = (Dali::Actor *)jarg1;
37234   {
37235     try {
37236       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37237     } catch (std::out_of_range& e) {
37238       {
37239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37240       };
37241     } catch (std::exception& e) {
37242       {
37243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37244       };
37245     } catch (Dali::DaliException e) {
37246       {
37247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37248       };
37249     } catch (...) {
37250       {
37251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37252       };
37253     }
37254   }
37255
37256   jresult = (void *)result;
37257   return jresult;
37258 }
37259
37260
37261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37262   Dali::Actor *arg1 = 0 ;
37263
37264   arg1 = (Dali::Actor *)jarg1;
37265   if (!arg1) {
37266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37267     return ;
37268   }
37269   {
37270     try {
37271       Dali::UnparentAndReset(*arg1);
37272     } catch (std::out_of_range& e) {
37273       {
37274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37275       };
37276     } catch (std::exception& e) {
37277       {
37278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37279       };
37280     } catch (Dali::DaliException e) {
37281       {
37282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37283       };
37284     } catch (...) {
37285       {
37286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37287       };
37288     }
37289   }
37290
37291 }
37292
37293
37294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37295   int jresult ;
37296   int result;
37297
37298   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37299   jresult = (int)result;
37300   return jresult;
37301 }
37302
37303
37304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37305   int jresult ;
37306   int result;
37307
37308   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37309   jresult = (int)result;
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37315   int jresult ;
37316   int result;
37317
37318   result = (int)Dali::Layer::Property::BEHAVIOR;
37319   jresult = (int)result;
37320   return jresult;
37321 }
37322
37323
37324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37325   void * jresult ;
37326   Dali::Layer::Property *result = 0 ;
37327
37328   {
37329     try {
37330       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37331     } catch (std::out_of_range& e) {
37332       {
37333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37334       };
37335     } catch (std::exception& e) {
37336       {
37337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37338       };
37339     } catch (Dali::DaliException e) {
37340       {
37341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37342       };
37343     } catch (...) {
37344       {
37345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37346       };
37347     }
37348   }
37349
37350   jresult = (void *)result;
37351   return jresult;
37352 }
37353
37354
37355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37356   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37357
37358   arg1 = (Dali::Layer::Property *)jarg1;
37359   {
37360     try {
37361       delete arg1;
37362     } catch (std::out_of_range& e) {
37363       {
37364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37365       };
37366     } catch (std::exception& e) {
37367       {
37368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37369       };
37370     } catch (Dali::DaliException e) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37377       };
37378     }
37379   }
37380
37381 }
37382
37383
37384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37385   void * jresult ;
37386   Dali::Layer *result = 0 ;
37387
37388   {
37389     try {
37390       result = (Dali::Layer *)new Dali::Layer();
37391     } catch (std::out_of_range& e) {
37392       {
37393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37394       };
37395     } catch (std::exception& e) {
37396       {
37397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (Dali::DaliException e) {
37400       {
37401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37402       };
37403     } catch (...) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37406       };
37407     }
37408   }
37409
37410   jresult = (void *)result;
37411   return jresult;
37412 }
37413
37414
37415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37416   void * jresult ;
37417   Dali::Layer result;
37418
37419   {
37420     try {
37421       result = Dali::Layer::New();
37422     } catch (std::out_of_range& e) {
37423       {
37424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37425       };
37426     } catch (std::exception& e) {
37427       {
37428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37429       };
37430     } catch (Dali::DaliException e) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37433       };
37434     } catch (...) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37437       };
37438     }
37439   }
37440
37441   jresult = new Dali::Layer((const Dali::Layer &)result);
37442   return jresult;
37443 }
37444
37445
37446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37447   void * jresult ;
37448   Dali::BaseHandle arg1 ;
37449   Dali::BaseHandle *argp1 ;
37450   Dali::Layer result;
37451
37452   argp1 = (Dali::BaseHandle *)jarg1;
37453   if (!argp1) {
37454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37455     return 0;
37456   }
37457   arg1 = *argp1;
37458   {
37459     try {
37460       result = Dali::Layer::DownCast(arg1);
37461     } catch (std::out_of_range& e) {
37462       {
37463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37464       };
37465     } catch (std::exception& e) {
37466       {
37467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37468       };
37469     } catch (Dali::DaliException e) {
37470       {
37471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37472       };
37473     } catch (...) {
37474       {
37475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37476       };
37477     }
37478   }
37479
37480   jresult = new Dali::Layer((const Dali::Layer &)result);
37481   return jresult;
37482 }
37483
37484
37485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37486   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37487
37488   arg1 = (Dali::Layer *)jarg1;
37489   {
37490     try {
37491       delete arg1;
37492     } catch (std::out_of_range& e) {
37493       {
37494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37495       };
37496     } catch (std::exception& e) {
37497       {
37498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37499       };
37500     } catch (Dali::DaliException e) {
37501       {
37502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37503       };
37504     } catch (...) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37507       };
37508     }
37509   }
37510
37511 }
37512
37513
37514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37515   void * jresult ;
37516   Dali::Layer *arg1 = 0 ;
37517   Dali::Layer *result = 0 ;
37518
37519   arg1 = (Dali::Layer *)jarg1;
37520   if (!arg1) {
37521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37522     return 0;
37523   }
37524   {
37525     try {
37526       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37542       };
37543     }
37544   }
37545
37546   jresult = (void *)result;
37547   return jresult;
37548 }
37549
37550
37551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37552   void * jresult ;
37553   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37554   Dali::Layer *arg2 = 0 ;
37555   Dali::Layer *result = 0 ;
37556
37557   arg1 = (Dali::Layer *)jarg1;
37558   arg2 = (Dali::Layer *)jarg2;
37559   if (!arg2) {
37560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37561     return 0;
37562   }
37563   {
37564     try {
37565       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37566     } catch (std::out_of_range& e) {
37567       {
37568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37569       };
37570     } catch (std::exception& e) {
37571       {
37572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37573       };
37574     } catch (Dali::DaliException e) {
37575       {
37576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37577       };
37578     } catch (...) {
37579       {
37580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37581       };
37582     }
37583   }
37584
37585   jresult = (void *)result;
37586   return jresult;
37587 }
37588
37589
37590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37591   unsigned int jresult ;
37592   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37593   unsigned int result;
37594
37595   arg1 = (Dali::Layer *)jarg1;
37596   {
37597     try {
37598       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37599     } catch (std::out_of_range& e) {
37600       {
37601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (std::exception& e) {
37604       {
37605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37606       };
37607     } catch (Dali::DaliException e) {
37608       {
37609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37610       };
37611     } catch (...) {
37612       {
37613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37614       };
37615     }
37616   }
37617
37618   jresult = result;
37619   return jresult;
37620 }
37621
37622
37623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37625
37626   arg1 = (Dali::Layer *)jarg1;
37627   {
37628     try {
37629       (arg1)->Raise();
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   {
37657     try {
37658       (arg1)->Lower();
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::Layer arg2 ;
37684   Dali::Layer *argp2 ;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   argp2 = (Dali::Layer *)jarg2;
37688   if (!argp2) {
37689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37690     return ;
37691   }
37692   arg2 = *argp2;
37693   {
37694     try {
37695       (arg1)->RaiseAbove(arg2);
37696     } catch (std::out_of_range& e) {
37697       {
37698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (std::exception& e) {
37701       {
37702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37703       };
37704     } catch (Dali::DaliException e) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37707       };
37708     } catch (...) {
37709       {
37710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37711       };
37712     }
37713   }
37714
37715 }
37716
37717
37718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37719   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37720   Dali::Layer arg2 ;
37721   Dali::Layer *argp2 ;
37722
37723   arg1 = (Dali::Layer *)jarg1;
37724   argp2 = (Dali::Layer *)jarg2;
37725   if (!argp2) {
37726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37727     return ;
37728   }
37729   arg2 = *argp2;
37730   {
37731     try {
37732       (arg1)->LowerBelow(arg2);
37733     } catch (std::out_of_range& e) {
37734       {
37735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37736       };
37737     } catch (std::exception& e) {
37738       {
37739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37740       };
37741     } catch (Dali::DaliException e) {
37742       {
37743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37744       };
37745     } catch (...) {
37746       {
37747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37748       };
37749     }
37750   }
37751
37752 }
37753
37754
37755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37756   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37757
37758   arg1 = (Dali::Layer *)jarg1;
37759   {
37760     try {
37761       (arg1)->RaiseToTop();
37762     } catch (std::out_of_range& e) {
37763       {
37764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (std::exception& e) {
37767       {
37768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (Dali::DaliException e) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780
37781 }
37782
37783
37784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37786
37787   arg1 = (Dali::Layer *)jarg1;
37788   {
37789     try {
37790       (arg1)->LowerToBottom();
37791     } catch (std::out_of_range& e) {
37792       {
37793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37794       };
37795     } catch (std::exception& e) {
37796       {
37797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37798       };
37799     } catch (Dali::DaliException e) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37802       };
37803     } catch (...) {
37804       {
37805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37806       };
37807     }
37808   }
37809
37810 }
37811
37812
37813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37815   Dali::Layer arg2 ;
37816   Dali::Layer *argp2 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   argp2 = (Dali::Layer *)jarg2;
37820   if (!argp2) {
37821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37822     return ;
37823   }
37824   arg2 = *argp2;
37825   {
37826     try {
37827       (arg1)->MoveAbove(arg2);
37828     } catch (std::out_of_range& e) {
37829       {
37830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37831       };
37832     } catch (std::exception& e) {
37833       {
37834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37835       };
37836     } catch (Dali::DaliException e) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37839       };
37840     } catch (...) {
37841       {
37842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37843       };
37844     }
37845   }
37846
37847 }
37848
37849
37850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37851   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37852   Dali::Layer arg2 ;
37853   Dali::Layer *argp2 ;
37854
37855   arg1 = (Dali::Layer *)jarg1;
37856   argp2 = (Dali::Layer *)jarg2;
37857   if (!argp2) {
37858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37859     return ;
37860   }
37861   arg2 = *argp2;
37862   {
37863     try {
37864       (arg1)->MoveBelow(arg2);
37865     } catch (std::out_of_range& e) {
37866       {
37867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37868       };
37869     } catch (std::exception& e) {
37870       {
37871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37872       };
37873     } catch (Dali::DaliException e) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37876       };
37877     } catch (...) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37880       };
37881     }
37882   }
37883
37884 }
37885
37886
37887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37889   Dali::Layer::Behavior arg2 ;
37890
37891   arg1 = (Dali::Layer *)jarg1;
37892   arg2 = (Dali::Layer::Behavior)jarg2;
37893   {
37894     try {
37895       (arg1)->SetBehavior(arg2);
37896     } catch (std::out_of_range& e) {
37897       {
37898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37899       };
37900     } catch (std::exception& e) {
37901       {
37902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37903       };
37904     } catch (Dali::DaliException e) {
37905       {
37906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37907       };
37908     } catch (...) {
37909       {
37910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37911       };
37912     }
37913   }
37914
37915 }
37916
37917
37918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37919   int jresult ;
37920   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37921   Dali::Layer::Behavior result;
37922
37923   arg1 = (Dali::Layer *)jarg1;
37924   {
37925     try {
37926       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37942       };
37943     }
37944   }
37945
37946   jresult = (int)result;
37947   return jresult;
37948 }
37949
37950
37951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37952   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37953   bool arg2 ;
37954
37955   arg1 = (Dali::Layer *)jarg1;
37956   arg2 = jarg2 ? true : false;
37957   {
37958     try {
37959       (arg1)->SetClipping(arg2);
37960     } catch (std::out_of_range& e) {
37961       {
37962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37963       };
37964     } catch (std::exception& e) {
37965       {
37966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37967       };
37968     } catch (Dali::DaliException e) {
37969       {
37970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37971       };
37972     } catch (...) {
37973       {
37974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37975       };
37976     }
37977   }
37978
37979 }
37980
37981
37982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37983   unsigned int jresult ;
37984   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37985   bool result;
37986
37987   arg1 = (Dali::Layer *)jarg1;
37988   {
37989     try {
37990       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37991     } catch (std::out_of_range& e) {
37992       {
37993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37994       };
37995     } catch (std::exception& e) {
37996       {
37997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37998       };
37999     } catch (Dali::DaliException e) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38002       };
38003     } catch (...) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38006       };
38007     }
38008   }
38009
38010   jresult = result;
38011   return jresult;
38012 }
38013
38014
38015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38016   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38017   int arg2 ;
38018   int arg3 ;
38019   int arg4 ;
38020   int arg5 ;
38021
38022   arg1 = (Dali::Layer *)jarg1;
38023   arg2 = (int)jarg2;
38024   arg3 = (int)jarg3;
38025   arg4 = (int)jarg4;
38026   arg5 = (int)jarg5;
38027   {
38028     try {
38029       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
38030     } catch (std::out_of_range& e) {
38031       {
38032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38033       };
38034     } catch (std::exception& e) {
38035       {
38036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38037       };
38038     } catch (Dali::DaliException e) {
38039       {
38040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38041       };
38042     } catch (...) {
38043       {
38044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38045       };
38046     }
38047   }
38048
38049 }
38050
38051
38052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38053   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38054   Dali::ClippingBox arg2 ;
38055   Dali::ClippingBox *argp2 ;
38056
38057   arg1 = (Dali::Layer *)jarg1;
38058   argp2 = (Dali::ClippingBox *)jarg2;
38059   if (!argp2) {
38060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38061     return ;
38062   }
38063   arg2 = *argp2;
38064   {
38065     try {
38066       (arg1)->SetClippingBox(arg2);
38067     } catch (std::out_of_range& e) {
38068       {
38069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (std::exception& e) {
38072       {
38073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38074       };
38075     } catch (Dali::DaliException e) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38078       };
38079     } catch (...) {
38080       {
38081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38082       };
38083     }
38084   }
38085
38086 }
38087
38088
38089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38090   void * jresult ;
38091   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38092   Dali::ClippingBox result;
38093
38094   arg1 = (Dali::Layer *)jarg1;
38095   {
38096     try {
38097       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38098     } catch (std::out_of_range& e) {
38099       {
38100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38101       };
38102     } catch (std::exception& e) {
38103       {
38104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38105       };
38106     } catch (Dali::DaliException e) {
38107       {
38108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38109       };
38110     } catch (...) {
38111       {
38112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38113       };
38114     }
38115   }
38116
38117   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38118   return jresult;
38119 }
38120
38121
38122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38123   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38124   bool arg2 ;
38125
38126   arg1 = (Dali::Layer *)jarg1;
38127   arg2 = jarg2 ? true : false;
38128   {
38129     try {
38130       (arg1)->SetDepthTestDisabled(arg2);
38131     } catch (std::out_of_range& e) {
38132       {
38133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38134       };
38135     } catch (std::exception& e) {
38136       {
38137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38138       };
38139     } catch (Dali::DaliException e) {
38140       {
38141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38142       };
38143     } catch (...) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38146       };
38147     }
38148   }
38149
38150 }
38151
38152
38153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38154   unsigned int jresult ;
38155   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38156   bool result;
38157
38158   arg1 = (Dali::Layer *)jarg1;
38159   {
38160     try {
38161       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38162     } catch (std::out_of_range& e) {
38163       {
38164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38165       };
38166     } catch (std::exception& e) {
38167       {
38168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38169       };
38170     } catch (Dali::DaliException e) {
38171       {
38172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38173       };
38174     } catch (...) {
38175       {
38176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38177       };
38178     }
38179   }
38180
38181   jresult = result;
38182   return jresult;
38183 }
38184
38185
38186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38187   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38188   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38189
38190   arg1 = (Dali::Layer *)jarg1;
38191   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38192   {
38193     try {
38194       (arg1)->SetSortFunction(arg2);
38195     } catch (std::out_of_range& e) {
38196       {
38197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38198       };
38199     } catch (std::exception& e) {
38200       {
38201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38202       };
38203     } catch (Dali::DaliException e) {
38204       {
38205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38206       };
38207     } catch (...) {
38208       {
38209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38210       };
38211     }
38212   }
38213
38214 }
38215
38216
38217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38218   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38219   bool arg2 ;
38220
38221   arg1 = (Dali::Layer *)jarg1;
38222   arg2 = jarg2 ? true : false;
38223   {
38224     try {
38225       (arg1)->SetTouchConsumed(arg2);
38226     } catch (std::out_of_range& e) {
38227       {
38228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38229       };
38230     } catch (std::exception& e) {
38231       {
38232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38233       };
38234     } catch (Dali::DaliException e) {
38235       {
38236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38237       };
38238     } catch (...) {
38239       {
38240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38241       };
38242     }
38243   }
38244
38245 }
38246
38247
38248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38249   unsigned int jresult ;
38250   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38251   bool result;
38252
38253   arg1 = (Dali::Layer *)jarg1;
38254   {
38255     try {
38256       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38257     } catch (std::out_of_range& e) {
38258       {
38259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38260       };
38261     } catch (std::exception& e) {
38262       {
38263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38264       };
38265     } catch (Dali::DaliException e) {
38266       {
38267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38268       };
38269     } catch (...) {
38270       {
38271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38272       };
38273     }
38274   }
38275
38276   jresult = result;
38277   return jresult;
38278 }
38279
38280
38281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38282   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38283   bool arg2 ;
38284
38285   arg1 = (Dali::Layer *)jarg1;
38286   arg2 = jarg2 ? true : false;
38287   {
38288     try {
38289       (arg1)->SetHoverConsumed(arg2);
38290     } catch (std::out_of_range& e) {
38291       {
38292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38293       };
38294     } catch (std::exception& e) {
38295       {
38296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38297       };
38298     } catch (Dali::DaliException e) {
38299       {
38300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38301       };
38302     } catch (...) {
38303       {
38304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38305       };
38306     }
38307   }
38308
38309 }
38310
38311
38312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38313   unsigned int jresult ;
38314   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38315   bool result;
38316
38317   arg1 = (Dali::Layer *)jarg1;
38318   {
38319     try {
38320       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38321     } catch (std::out_of_range& e) {
38322       {
38323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38324       };
38325     } catch (std::exception& e) {
38326       {
38327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38328       };
38329     } catch (Dali::DaliException e) {
38330       {
38331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38332       };
38333     } catch (...) {
38334       {
38335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38336       };
38337     }
38338   }
38339
38340   jresult = result;
38341   return jresult;
38342 }
38343
38344
38345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38346   void * jresult ;
38347   Dali::Vector4 *result = 0 ;
38348
38349   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38350   jresult = (void *)result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38356   void * jresult ;
38357   Dali::Vector4 *result = 0 ;
38358
38359   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38366   void * jresult ;
38367   Dali::Stage *result = 0 ;
38368
38369   {
38370     try {
38371       result = (Dali::Stage *)new Dali::Stage();
38372     } catch (std::out_of_range& e) {
38373       {
38374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38375       };
38376     } catch (std::exception& e) {
38377       {
38378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38379       };
38380     } catch (Dali::DaliException e) {
38381       {
38382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38383       };
38384     } catch (...) {
38385       {
38386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38387       };
38388     }
38389   }
38390
38391   jresult = (void *)result;
38392   return jresult;
38393 }
38394
38395
38396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38397   void * jresult ;
38398   Dali::Stage result;
38399
38400   {
38401     try {
38402       result = Dali::Stage::GetCurrent();
38403     } catch (std::out_of_range& e) {
38404       {
38405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38406       };
38407     } catch (std::exception& e) {
38408       {
38409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38410       };
38411     } catch (Dali::DaliException e) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38414       };
38415     } catch (...) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38418       };
38419     }
38420   }
38421
38422   jresult = new Dali::Stage((const Dali::Stage &)result);
38423   return jresult;
38424 }
38425
38426
38427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38428   unsigned int jresult ;
38429   bool result;
38430
38431   {
38432     try {
38433       result = (bool)Dali::Stage::IsInstalled();
38434     } catch (std::out_of_range& e) {
38435       {
38436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (std::exception& e) {
38439       {
38440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (Dali::DaliException e) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38445       };
38446     } catch (...) {
38447       {
38448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38449       };
38450     }
38451   }
38452
38453   jresult = result;
38454   return jresult;
38455 }
38456
38457
38458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38459   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38460
38461   arg1 = (Dali::Stage *)jarg1;
38462   {
38463     try {
38464       delete arg1;
38465     } catch (std::out_of_range& e) {
38466       {
38467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38468       };
38469     } catch (std::exception& e) {
38470       {
38471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38472       };
38473     } catch (Dali::DaliException e) {
38474       {
38475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38476       };
38477     } catch (...) {
38478       {
38479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38480       };
38481     }
38482   }
38483
38484 }
38485
38486
38487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38488   void * jresult ;
38489   Dali::Stage *arg1 = 0 ;
38490   Dali::Stage *result = 0 ;
38491
38492   arg1 = (Dali::Stage *)jarg1;
38493   if (!arg1) {
38494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38495     return 0;
38496   }
38497   {
38498     try {
38499       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38500     } catch (std::out_of_range& e) {
38501       {
38502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38503       };
38504     } catch (std::exception& e) {
38505       {
38506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38507       };
38508     } catch (Dali::DaliException e) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38511       };
38512     } catch (...) {
38513       {
38514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38515       };
38516     }
38517   }
38518
38519   jresult = (void *)result;
38520   return jresult;
38521 }
38522
38523
38524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38525   void * jresult ;
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   Dali::Stage *arg2 = 0 ;
38528   Dali::Stage *result = 0 ;
38529
38530   arg1 = (Dali::Stage *)jarg1;
38531   arg2 = (Dali::Stage *)jarg2;
38532   if (!arg2) {
38533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38534     return 0;
38535   }
38536   {
38537     try {
38538       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = (void *)result;
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38564   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38565   Dali::Actor *arg2 = 0 ;
38566
38567   arg1 = (Dali::Stage *)jarg1;
38568   arg2 = (Dali::Actor *)jarg2;
38569   if (!arg2) {
38570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38571     return ;
38572   }
38573   {
38574     try {
38575       (arg1)->Add(*arg2);
38576     } catch (std::out_of_range& e) {
38577       {
38578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38579       };
38580     } catch (std::exception& e) {
38581       {
38582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38583       };
38584     } catch (Dali::DaliException e) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38587       };
38588     } catch (...) {
38589       {
38590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38591       };
38592     }
38593   }
38594
38595 }
38596
38597
38598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38599   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38600   Dali::Actor *arg2 = 0 ;
38601
38602   arg1 = (Dali::Stage *)jarg1;
38603   arg2 = (Dali::Actor *)jarg2;
38604   if (!arg2) {
38605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38606     return ;
38607   }
38608   {
38609     try {
38610       (arg1)->Remove(*arg2);
38611     } catch (std::out_of_range& e) {
38612       {
38613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38614       };
38615     } catch (std::exception& e) {
38616       {
38617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38618       };
38619     } catch (Dali::DaliException e) {
38620       {
38621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38622       };
38623     } catch (...) {
38624       {
38625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38626       };
38627     }
38628   }
38629
38630 }
38631
38632
38633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38634   void * jresult ;
38635   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38636   Dali::Vector2 result;
38637
38638   arg1 = (Dali::Stage *)jarg1;
38639   {
38640     try {
38641       result = ((Dali::Stage const *)arg1)->GetSize();
38642     } catch (std::out_of_range& e) {
38643       {
38644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38645       };
38646     } catch (std::exception& e) {
38647       {
38648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38649       };
38650     } catch (Dali::DaliException e) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38653       };
38654     } catch (...) {
38655       {
38656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38657       };
38658     }
38659   }
38660
38661   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38662   return jresult;
38663 }
38664
38665
38666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38667   void * jresult ;
38668   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38669   Dali::RenderTaskList result;
38670
38671   arg1 = (Dali::Stage *)jarg1;
38672   {
38673     try {
38674       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38675     } catch (std::out_of_range& e) {
38676       {
38677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (std::exception& e) {
38680       {
38681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38682       };
38683     } catch (Dali::DaliException e) {
38684       {
38685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38686       };
38687     } catch (...) {
38688       {
38689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38690       };
38691     }
38692   }
38693
38694   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38695   return jresult;
38696 }
38697
38698
38699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38700   unsigned int jresult ;
38701   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38702   unsigned int result;
38703
38704   arg1 = (Dali::Stage *)jarg1;
38705   {
38706     try {
38707       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38708     } catch (std::out_of_range& e) {
38709       {
38710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (std::exception& e) {
38713       {
38714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38715       };
38716     } catch (Dali::DaliException e) {
38717       {
38718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38719       };
38720     } catch (...) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38723       };
38724     }
38725   }
38726
38727   jresult = result;
38728   return jresult;
38729 }
38730
38731
38732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38733   void * jresult ;
38734   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38735   unsigned int arg2 ;
38736   Dali::Layer result;
38737
38738   arg1 = (Dali::Stage *)jarg1;
38739   arg2 = (unsigned int)jarg2;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (Dali::DaliException e) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761
38762   jresult = new Dali::Layer((const Dali::Layer &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38768   void * jresult ;
38769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38770   Dali::Layer result;
38771
38772   arg1 = (Dali::Stage *)jarg1;
38773   {
38774     try {
38775       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38791       };
38792     }
38793   }
38794
38795   jresult = new Dali::Layer((const Dali::Layer &)result);
38796   return jresult;
38797 }
38798
38799
38800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38801   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38802   Dali::Vector4 arg2 ;
38803   Dali::Vector4 *argp2 ;
38804
38805   arg1 = (Dali::Stage *)jarg1;
38806   argp2 = (Dali::Vector4 *)jarg2;
38807   if (!argp2) {
38808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38809     return ;
38810   }
38811   arg2 = *argp2;
38812   {
38813     try {
38814       (arg1)->SetBackgroundColor(arg2);
38815     } catch (std::out_of_range& e) {
38816       {
38817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38818       };
38819     } catch (std::exception& e) {
38820       {
38821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38822       };
38823     } catch (Dali::DaliException e) {
38824       {
38825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38826       };
38827     } catch (...) {
38828       {
38829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38830       };
38831     }
38832   }
38833
38834 }
38835
38836
38837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38838   void * jresult ;
38839   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38840   Dali::Vector4 result;
38841
38842   arg1 = (Dali::Stage *)jarg1;
38843   {
38844     try {
38845       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38846     } catch (std::out_of_range& e) {
38847       {
38848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38849       };
38850     } catch (std::exception& e) {
38851       {
38852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38853       };
38854     } catch (Dali::DaliException e) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38857       };
38858     } catch (...) {
38859       {
38860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38861       };
38862     }
38863   }
38864
38865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38866   return jresult;
38867 }
38868
38869
38870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38871   void * jresult ;
38872   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38873   Dali::Vector2 result;
38874
38875   arg1 = (Dali::Stage *)jarg1;
38876   {
38877     try {
38878       result = ((Dali::Stage const *)arg1)->GetDpi();
38879     } catch (std::out_of_range& e) {
38880       {
38881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38882       };
38883     } catch (std::exception& e) {
38884       {
38885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38886       };
38887     } catch (Dali::DaliException e) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38890       };
38891     } catch (...) {
38892       {
38893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38894       };
38895     }
38896   }
38897
38898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38899   return jresult;
38900 }
38901
38902
38903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38904   void * jresult ;
38905   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38906   Dali::ObjectRegistry result;
38907
38908   arg1 = (Dali::Stage *)jarg1;
38909   {
38910     try {
38911       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38912     } catch (std::out_of_range& e) {
38913       {
38914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38915       };
38916     } catch (std::exception& e) {
38917       {
38918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38919       };
38920     } catch (Dali::DaliException e) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38923       };
38924     } catch (...) {
38925       {
38926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38927       };
38928     }
38929   }
38930
38931   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38937   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38938   float arg2 ;
38939
38940   arg1 = (Dali::Stage *)jarg1;
38941   arg2 = (float)jarg2;
38942   {
38943     try {
38944       (arg1)->KeepRendering(arg2);
38945     } catch (std::out_of_range& e) {
38946       {
38947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38948       };
38949     } catch (std::exception& e) {
38950       {
38951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38952       };
38953     } catch (Dali::DaliException e) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38960       };
38961     }
38962   }
38963
38964 }
38965
38966
38967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38968   void * jresult ;
38969   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38970   Dali::Stage::KeyEventSignalType *result = 0 ;
38971
38972   arg1 = (Dali::Stage *)jarg1;
38973   {
38974     try {
38975       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (Dali::DaliException e) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38987       };
38988     } catch (...) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38991       };
38992     }
38993   }
38994
38995   jresult = (void *)result;
38996   return jresult;
38997 }
38998
38999
39000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
39001   void * jresult ;
39002   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39003   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
39004
39005   arg1 = (Dali::Stage *)jarg1;
39006   {
39007     try {
39008       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39009     } catch (std::out_of_range& e) {
39010       {
39011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (std::exception& e) {
39014       {
39015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39016       };
39017     } catch (Dali::DaliException e) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39020       };
39021     } catch (...) {
39022       {
39023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39024       };
39025     }
39026   }
39027
39028   jresult = (void *)result;
39029   return jresult;
39030 }
39031
39032
39033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39034   void * jresult ;
39035   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39036   Dali::Stage::TouchSignalType *result = 0 ;
39037
39038   arg1 = (Dali::Stage *)jarg1;
39039   {
39040     try {
39041       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39042     } catch (std::out_of_range& e) {
39043       {
39044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (std::exception& e) {
39047       {
39048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (Dali::DaliException e) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39053       };
39054     } catch (...) {
39055       {
39056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39057       };
39058     }
39059   }
39060
39061   jresult = (void *)result;
39062   return jresult;
39063 }
39064
39065
39066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39067   void * jresult ;
39068   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39069   Dali::Stage::WheelEventSignalType *result = 0 ;
39070
39071   arg1 = (Dali::Stage *)jarg1;
39072   {
39073     try {
39074       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39075     } catch (std::out_of_range& e) {
39076       {
39077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (std::exception& e) {
39080       {
39081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (Dali::DaliException e) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39086       };
39087     } catch (...) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39090       };
39091     }
39092   }
39093
39094   jresult = (void *)result;
39095   return jresult;
39096 }
39097
39098
39099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39100   void * jresult ;
39101   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39102   Dali::Stage::ContextStatusSignal *result = 0 ;
39103
39104   arg1 = (Dali::Stage *)jarg1;
39105   {
39106     try {
39107       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39108     } catch (std::out_of_range& e) {
39109       {
39110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39111       };
39112     } catch (std::exception& e) {
39113       {
39114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39115       };
39116     } catch (Dali::DaliException e) {
39117       {
39118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39119       };
39120     } catch (...) {
39121       {
39122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39123       };
39124     }
39125   }
39126
39127   jresult = (void *)result;
39128   return jresult;
39129 }
39130
39131
39132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39133   void * jresult ;
39134   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39135   Dali::Stage::ContextStatusSignal *result = 0 ;
39136
39137   arg1 = (Dali::Stage *)jarg1;
39138   {
39139     try {
39140       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39141     } catch (std::out_of_range& e) {
39142       {
39143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39144       };
39145     } catch (std::exception& e) {
39146       {
39147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39148       };
39149     } catch (Dali::DaliException e) {
39150       {
39151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39152       };
39153     } catch (...) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39156       };
39157     }
39158   }
39159
39160   jresult = (void *)result;
39161   return jresult;
39162 }
39163
39164
39165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39166   void * jresult ;
39167   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39168   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39169
39170   arg1 = (Dali::Stage *)jarg1;
39171   {
39172     try {
39173       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39181       };
39182     } catch (Dali::DaliException e) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39189       };
39190     }
39191   }
39192
39193   jresult = (void *)result;
39194   return jresult;
39195 }
39196
39197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39198   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39199   Dali::DevelStage::Rendering arg2 ;
39200
39201   arg1 = (Dali::Stage *)jarg1;
39202   arg2 = (Dali::DevelStage::Rendering)jarg2;
39203   {
39204     try {
39205       DevelStage::SetRenderingBehavior(*arg1,arg2);
39206     } catch (std::out_of_range& e) {
39207       {
39208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39209       };
39210     } catch (std::exception& e) {
39211       {
39212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39213       };
39214     } catch (Dali::DaliException e) {
39215       {
39216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39217       };
39218     } catch (...) {
39219       {
39220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39221       };
39222     }
39223   }
39224
39225 }
39226
39227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39228
39229   int jresult ;
39230   int result ;
39231   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39232
39233   arg1 = (Dali::Stage *)jarg1;
39234   {
39235     try {
39236       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39237     } catch (std::out_of_range& e) {
39238       {
39239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39240       };
39241     } catch (std::exception& e) {
39242       {
39243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39244       };
39245     } catch (Dali::DaliException e) {
39246       {
39247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39248       };
39249     } catch (...) {
39250       {
39251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39252       };
39253     }
39254   }
39255
39256   jresult = result;
39257   return jresult;
39258 }
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39261   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39262
39263   arg1 = (Dali::RelayoutContainer *)jarg1;
39264   {
39265     try {
39266       delete arg1;
39267     } catch (std::out_of_range& e) {
39268       {
39269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39270       };
39271     } catch (std::exception& e) {
39272       {
39273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (Dali::DaliException e) {
39276       {
39277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39282       };
39283     }
39284   }
39285
39286 }
39287
39288
39289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39290   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39291   Dali::Actor *arg2 = 0 ;
39292   Dali::Vector2 *arg3 = 0 ;
39293
39294   arg1 = (Dali::RelayoutContainer *)jarg1;
39295   arg2 = (Dali::Actor *)jarg2;
39296   if (!arg2) {
39297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39298     return ;
39299   }
39300   arg3 = (Dali::Vector2 *)jarg3;
39301   if (!arg3) {
39302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39303     return ;
39304   }
39305   {
39306     try {
39307       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39308     } catch (std::out_of_range& e) {
39309       {
39310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39311       };
39312     } catch (std::exception& e) {
39313       {
39314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39315       };
39316     } catch (Dali::DaliException e) {
39317       {
39318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39319       };
39320     } catch (...) {
39321       {
39322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39323       };
39324     }
39325   }
39326
39327 }
39328
39329
39330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39331   void * jresult ;
39332   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39333   Dali::CustomActor result;
39334
39335   arg1 = (Dali::CustomActorImpl *)jarg1;
39336   {
39337     try {
39338       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39339     } catch (std::out_of_range& e) {
39340       {
39341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39342       };
39343     } catch (std::exception& e) {
39344       {
39345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39346       };
39347     } catch (Dali::DaliException e) {
39348       {
39349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39350       };
39351     } catch (...) {
39352       {
39353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39354       };
39355     }
39356   }
39357
39358   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39359   return jresult;
39360 }
39361
39362
39363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39364   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39365   int arg2 ;
39366
39367   arg1 = (Dali::CustomActorImpl *)jarg1;
39368   arg2 = (int)jarg2;
39369   {
39370     try {
39371       (arg1)->OnStageConnection(arg2);
39372     } catch (std::out_of_range& e) {
39373       {
39374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39375       };
39376     } catch (std::exception& e) {
39377       {
39378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39379       };
39380     } catch (Dali::DaliException e) {
39381       {
39382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39383       };
39384     } catch (...) {
39385       {
39386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39387       };
39388     }
39389   }
39390
39391 }
39392
39393
39394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39395   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39396
39397   arg1 = (Dali::CustomActorImpl *)jarg1;
39398   {
39399     try {
39400       (arg1)->OnStageDisconnection();
39401     } catch (std::out_of_range& e) {
39402       {
39403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39404       };
39405     } catch (std::exception& e) {
39406       {
39407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39408       };
39409     } catch (Dali::DaliException e) {
39410       {
39411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39412       };
39413     } catch (...) {
39414       {
39415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39416       };
39417     }
39418   }
39419
39420 }
39421
39422
39423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39424   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39425   Dali::Actor *arg2 = 0 ;
39426
39427   arg1 = (Dali::CustomActorImpl *)jarg1;
39428   arg2 = (Dali::Actor *)jarg2;
39429   if (!arg2) {
39430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39431     return ;
39432   }
39433   {
39434     try {
39435       (arg1)->OnChildAdd(*arg2);
39436     } catch (std::out_of_range& e) {
39437       {
39438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39439       };
39440     } catch (std::exception& e) {
39441       {
39442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39443       };
39444     } catch (Dali::DaliException e) {
39445       {
39446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39447       };
39448     } catch (...) {
39449       {
39450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39451       };
39452     }
39453   }
39454
39455 }
39456
39457
39458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39460   Dali::Actor *arg2 = 0 ;
39461
39462   arg1 = (Dali::CustomActorImpl *)jarg1;
39463   arg2 = (Dali::Actor *)jarg2;
39464   if (!arg2) {
39465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39466     return ;
39467   }
39468   {
39469     try {
39470       (arg1)->OnChildRemove(*arg2);
39471     } catch (std::out_of_range& e) {
39472       {
39473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39474       };
39475     } catch (std::exception& e) {
39476       {
39477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39478       };
39479     } catch (Dali::DaliException e) {
39480       {
39481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39482       };
39483     } catch (...) {
39484       {
39485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39486       };
39487     }
39488   }
39489
39490 }
39491
39492
39493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39494   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39495   Dali::Property::Index arg2 ;
39496   Dali::Property::Value arg3 ;
39497   Dali::Property::Value *argp3 ;
39498
39499   arg1 = (Dali::CustomActorImpl *)jarg1;
39500   arg2 = (Dali::Property::Index)jarg2;
39501   argp3 = (Dali::Property::Value *)jarg3;
39502   if (!argp3) {
39503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39504     return ;
39505   }
39506   arg3 = *argp3;
39507   {
39508     try {
39509       (arg1)->OnPropertySet(arg2,arg3);
39510     } catch (std::out_of_range& e) {
39511       {
39512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39513       };
39514     } catch (std::exception& e) {
39515       {
39516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39517       };
39518     } catch (Dali::DaliException e) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39521       };
39522     } catch (...) {
39523       {
39524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39525       };
39526     }
39527   }
39528
39529 }
39530
39531
39532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39533   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39534   Dali::Vector3 *arg2 = 0 ;
39535
39536   arg1 = (Dali::CustomActorImpl *)jarg1;
39537   arg2 = (Dali::Vector3 *)jarg2;
39538   if (!arg2) {
39539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39540     return ;
39541   }
39542   {
39543     try {
39544       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39545     } catch (std::out_of_range& e) {
39546       {
39547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (std::exception& e) {
39550       {
39551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39552       };
39553     } catch (Dali::DaliException e) {
39554       {
39555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39556       };
39557     } catch (...) {
39558       {
39559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39560       };
39561     }
39562   }
39563
39564 }
39565
39566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39567   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39568   Dali::Animation *arg2 = 0 ;
39569   Dali::Vector3 *arg3 = 0 ;
39570
39571   arg1 = (Dali::CustomActorImpl *)jarg1;
39572   arg2 = (Dali::Animation *)jarg2;
39573   if (!arg2) {
39574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39575     return ;
39576   }
39577   arg3 = (Dali::Vector3 *)jarg3;
39578   if (!arg3) {
39579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39580     return ;
39581   }
39582   {
39583     try {
39584       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39585     } catch (std::out_of_range& e) {
39586       {
39587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39588       };
39589     } catch (std::exception& e) {
39590       {
39591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39592       };
39593     } catch (Dali::DaliException e) {
39594       {
39595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39596       };
39597     } catch (...) {
39598       {
39599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39600       };
39601     }
39602   }
39603
39604 }
39605
39606
39607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39608   unsigned int jresult ;
39609   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39610   Dali::TouchEvent *arg2 = 0 ;
39611   bool result;
39612
39613   arg1 = (Dali::CustomActorImpl *)jarg1;
39614   arg2 = (Dali::TouchEvent *)jarg2;
39615   if (!arg2) {
39616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39617     return 0;
39618   }
39619   {
39620     try {
39621       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39622     } catch (std::out_of_range& e) {
39623       {
39624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39625       };
39626     } catch (std::exception& e) {
39627       {
39628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39629       };
39630     } catch (Dali::DaliException e) {
39631       {
39632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39633       };
39634     } catch (...) {
39635       {
39636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39637       };
39638     }
39639   }
39640
39641   jresult = result;
39642   return jresult;
39643 }
39644
39645
39646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39647   unsigned int jresult ;
39648   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39649   Dali::HoverEvent *arg2 = 0 ;
39650   bool result;
39651
39652   arg1 = (Dali::CustomActorImpl *)jarg1;
39653   arg2 = (Dali::HoverEvent *)jarg2;
39654   if (!arg2) {
39655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39656     return 0;
39657   }
39658   {
39659     try {
39660       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39661     } catch (std::out_of_range& e) {
39662       {
39663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39664       };
39665     } catch (std::exception& e) {
39666       {
39667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39668       };
39669     } catch (Dali::DaliException e) {
39670       {
39671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39672       };
39673     } catch (...) {
39674       {
39675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39676       };
39677     }
39678   }
39679
39680   jresult = result;
39681   return jresult;
39682 }
39683
39684
39685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39686   unsigned int jresult ;
39687   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39688   Dali::KeyEvent *arg2 = 0 ;
39689   bool result;
39690
39691   arg1 = (Dali::CustomActorImpl *)jarg1;
39692   arg2 = (Dali::KeyEvent *)jarg2;
39693   if (!arg2) {
39694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39695     return 0;
39696   }
39697   {
39698     try {
39699       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39707       };
39708     } catch (Dali::DaliException e) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39715       };
39716     }
39717   }
39718
39719   jresult = result;
39720   return jresult;
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39725   unsigned int jresult ;
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   Dali::WheelEvent *arg2 = 0 ;
39728   bool result;
39729
39730   arg1 = (Dali::CustomActorImpl *)jarg1;
39731   arg2 = (Dali::WheelEvent *)jarg2;
39732   if (!arg2) {
39733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39734     return 0;
39735   }
39736   {
39737     try {
39738       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39739     } catch (std::out_of_range& e) {
39740       {
39741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39742       };
39743     } catch (std::exception& e) {
39744       {
39745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39746       };
39747     } catch (Dali::DaliException e) {
39748       {
39749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39750       };
39751     } catch (...) {
39752       {
39753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39754       };
39755     }
39756   }
39757
39758   jresult = result;
39759   return jresult;
39760 }
39761
39762
39763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39764   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39765   Dali::Vector2 *arg2 = 0 ;
39766   Dali::RelayoutContainer *arg3 = 0 ;
39767
39768   arg1 = (Dali::CustomActorImpl *)jarg1;
39769   arg2 = (Dali::Vector2 *)jarg2;
39770   if (!arg2) {
39771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39772     return ;
39773   }
39774   arg3 = (Dali::RelayoutContainer *)jarg3;
39775   if (!arg3) {
39776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39777     return ;
39778   }
39779   {
39780     try {
39781       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39782     } catch (std::out_of_range& e) {
39783       {
39784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39785       };
39786     } catch (std::exception& e) {
39787       {
39788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39789       };
39790     } catch (Dali::DaliException e) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39797       };
39798     }
39799   }
39800
39801 }
39802
39803
39804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39805   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39806   Dali::ResizePolicy::Type arg2 ;
39807   Dali::Dimension::Type arg3 ;
39808
39809   arg1 = (Dali::CustomActorImpl *)jarg1;
39810   arg2 = (Dali::ResizePolicy::Type)jarg2;
39811   arg3 = (Dali::Dimension::Type)jarg3;
39812   {
39813     try {
39814       (arg1)->OnSetResizePolicy(arg2,arg3);
39815     } catch (std::out_of_range& e) {
39816       {
39817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39818       };
39819     } catch (std::exception& e) {
39820       {
39821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39822       };
39823     } catch (Dali::DaliException e) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39826       };
39827     } catch (...) {
39828       {
39829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39830       };
39831     }
39832   }
39833
39834 }
39835
39836
39837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39838   void * jresult ;
39839   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39840   Dali::Vector3 result;
39841
39842   arg1 = (Dali::CustomActorImpl *)jarg1;
39843   {
39844     try {
39845       result = (arg1)->GetNaturalSize();
39846     } catch (std::out_of_range& e) {
39847       {
39848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39849       };
39850     } catch (std::exception& e) {
39851       {
39852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39853       };
39854     } catch (Dali::DaliException e) {
39855       {
39856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39857       };
39858     } catch (...) {
39859       {
39860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39861       };
39862     }
39863   }
39864
39865   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39866   return jresult;
39867 }
39868
39869
39870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39871   float jresult ;
39872   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39873   Dali::Actor *arg2 = 0 ;
39874   Dali::Dimension::Type arg3 ;
39875   float result;
39876
39877   arg1 = (Dali::CustomActorImpl *)jarg1;
39878   arg2 = (Dali::Actor *)jarg2;
39879   if (!arg2) {
39880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39881     return 0;
39882   }
39883   arg3 = (Dali::Dimension::Type)jarg3;
39884   {
39885     try {
39886       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39887     } catch (std::out_of_range& e) {
39888       {
39889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39890       };
39891     } catch (std::exception& e) {
39892       {
39893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39894       };
39895     } catch (Dali::DaliException e) {
39896       {
39897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39898       };
39899     } catch (...) {
39900       {
39901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39902       };
39903     }
39904   }
39905
39906   jresult = result;
39907   return jresult;
39908 }
39909
39910
39911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39912   float jresult ;
39913   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39914   float arg2 ;
39915   float result;
39916
39917   arg1 = (Dali::CustomActorImpl *)jarg1;
39918   arg2 = (float)jarg2;
39919   {
39920     try {
39921       result = (float)(arg1)->GetHeightForWidth(arg2);
39922     } catch (std::out_of_range& e) {
39923       {
39924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39925       };
39926     } catch (std::exception& e) {
39927       {
39928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39929       };
39930     } catch (Dali::DaliException e) {
39931       {
39932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39933       };
39934     } catch (...) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39937       };
39938     }
39939   }
39940
39941   jresult = result;
39942   return jresult;
39943 }
39944
39945
39946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39947   float jresult ;
39948   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39949   float arg2 ;
39950   float result;
39951
39952   arg1 = (Dali::CustomActorImpl *)jarg1;
39953   arg2 = (float)jarg2;
39954   {
39955     try {
39956       result = (float)(arg1)->GetWidthForHeight(arg2);
39957     } catch (std::out_of_range& e) {
39958       {
39959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (std::exception& e) {
39962       {
39963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (Dali::DaliException e) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39968       };
39969     } catch (...) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39972       };
39973     }
39974   }
39975
39976   jresult = result;
39977   return jresult;
39978 }
39979
39980
39981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39982   unsigned int jresult ;
39983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39984   Dali::Dimension::Type arg2 ;
39985   bool result;
39986
39987   arg1 = (Dali::CustomActorImpl *)jarg1;
39988   arg2 = (Dali::Dimension::Type)jarg2;
39989   {
39990     try {
39991       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39992     } catch (std::out_of_range& e) {
39993       {
39994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39995       };
39996     } catch (std::exception& e) {
39997       {
39998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39999       };
40000     } catch (Dali::DaliException e) {
40001       {
40002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40003       };
40004     } catch (...) {
40005       {
40006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40007       };
40008     }
40009   }
40010
40011   jresult = result;
40012   return jresult;
40013 }
40014
40015
40016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40017   unsigned int jresult ;
40018   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40019   bool result;
40020
40021   arg1 = (Dali::CustomActorImpl *)jarg1;
40022   {
40023     try {
40024       result = (bool)(arg1)->RelayoutDependentOnChildren();
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40032       };
40033     } catch (Dali::DaliException e) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40036       };
40037     } catch (...) {
40038       {
40039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40040       };
40041     }
40042   }
40043
40044   jresult = result;
40045   return jresult;
40046 }
40047
40048
40049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40050   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40051   Dali::Dimension::Type arg2 ;
40052
40053   arg1 = (Dali::CustomActorImpl *)jarg1;
40054   arg2 = (Dali::Dimension::Type)jarg2;
40055   {
40056     try {
40057       (arg1)->OnCalculateRelayoutSize(arg2);
40058     } catch (std::out_of_range& e) {
40059       {
40060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40061       };
40062     } catch (std::exception& e) {
40063       {
40064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40065       };
40066     } catch (Dali::DaliException e) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40069       };
40070     } catch (...) {
40071       {
40072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40073       };
40074     }
40075   }
40076
40077 }
40078
40079
40080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40081   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40082   float arg2 ;
40083   Dali::Dimension::Type arg3 ;
40084
40085   arg1 = (Dali::CustomActorImpl *)jarg1;
40086   arg2 = (float)jarg2;
40087   arg3 = (Dali::Dimension::Type)jarg3;
40088   {
40089     try {
40090       (arg1)->OnLayoutNegotiated(arg2,arg3);
40091     } catch (std::out_of_range& e) {
40092       {
40093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40094       };
40095     } catch (std::exception& e) {
40096       {
40097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40098       };
40099     } catch (Dali::DaliException e) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40102       };
40103     } catch (...) {
40104       {
40105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40106       };
40107     }
40108   }
40109
40110 }
40111
40112
40113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40114   unsigned int jresult ;
40115   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40116   bool result;
40117
40118   arg1 = (Dali::CustomActorImpl *)jarg1;
40119   {
40120     try {
40121       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40122     } catch (std::out_of_range& e) {
40123       {
40124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40125       };
40126     } catch (std::exception& e) {
40127       {
40128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (Dali::DaliException e) {
40131       {
40132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40133       };
40134     } catch (...) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40137       };
40138     }
40139   }
40140
40141   jresult = result;
40142   return jresult;
40143 }
40144
40145
40146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40147   unsigned int jresult ;
40148   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40149   bool result;
40150
40151   arg1 = (Dali::CustomActorImpl *)jarg1;
40152   {
40153     try {
40154       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40155     } catch (std::out_of_range& e) {
40156       {
40157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40158       };
40159     } catch (std::exception& e) {
40160       {
40161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40162       };
40163     } catch (Dali::DaliException e) {
40164       {
40165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40166       };
40167     } catch (...) {
40168       {
40169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40170       };
40171     }
40172   }
40173
40174   jresult = result;
40175   return jresult;
40176 }
40177
40178
40179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40180   unsigned int jresult ;
40181   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40182   bool result;
40183
40184   arg1 = (Dali::CustomActorImpl *)jarg1;
40185   {
40186     try {
40187       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40188     } catch (std::out_of_range& e) {
40189       {
40190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (std::exception& e) {
40193       {
40194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (Dali::DaliException e) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40199       };
40200     } catch (...) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40203       };
40204     }
40205   }
40206
40207   jresult = result;
40208   return jresult;
40209 }
40210
40211
40212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40213   unsigned int jresult ;
40214   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40215   bool result;
40216
40217   arg1 = (Dali::CustomActorImpl *)jarg1;
40218   {
40219     try {
40220       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40221     } catch (std::out_of_range& e) {
40222       {
40223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40224       };
40225     } catch (std::exception& e) {
40226       {
40227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (Dali::DaliException e) {
40230       {
40231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40232       };
40233     } catch (...) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40236       };
40237     }
40238   }
40239
40240   jresult = result;
40241   return jresult;
40242 }
40243
40244
40245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40246   void * jresult ;
40247   Dali::CustomActor *result = 0 ;
40248
40249   {
40250     try {
40251       result = (Dali::CustomActor *)new Dali::CustomActor();
40252     } catch (std::out_of_range& e) {
40253       {
40254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40255       };
40256     } catch (std::exception& e) {
40257       {
40258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40259       };
40260     } catch (Dali::DaliException e) {
40261       {
40262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40263       };
40264     } catch (...) {
40265       {
40266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40267       };
40268     }
40269   }
40270
40271   jresult = (void *)result;
40272   return jresult;
40273 }
40274
40275
40276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40277   void * jresult ;
40278   Dali::BaseHandle arg1 ;
40279   Dali::BaseHandle *argp1 ;
40280   Dali::CustomActor result;
40281
40282   argp1 = (Dali::BaseHandle *)jarg1;
40283   if (!argp1) {
40284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40285     return 0;
40286   }
40287   arg1 = *argp1;
40288   {
40289     try {
40290       result = Dali::CustomActor::DownCast(arg1);
40291     } catch (std::out_of_range& e) {
40292       {
40293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (std::exception& e) {
40296       {
40297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40298       };
40299     } catch (Dali::DaliException e) {
40300       {
40301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40302       };
40303     } catch (...) {
40304       {
40305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40306       };
40307     }
40308   }
40309
40310   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40311   return jresult;
40312 }
40313
40314
40315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40316   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40317
40318   arg1 = (Dali::CustomActor *)jarg1;
40319   {
40320     try {
40321       delete arg1;
40322     } catch (std::out_of_range& e) {
40323       {
40324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40325       };
40326     } catch (std::exception& e) {
40327       {
40328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40329       };
40330     } catch (Dali::DaliException e) {
40331       {
40332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40333       };
40334     } catch (...) {
40335       {
40336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40337       };
40338     }
40339   }
40340
40341 }
40342
40343
40344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40345   void * jresult ;
40346   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40347   Dali::CustomActorImpl *result = 0 ;
40348
40349   arg1 = (Dali::CustomActor *)jarg1;
40350   {
40351     try {
40352       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40353     } catch (std::out_of_range& e) {
40354       {
40355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40356       };
40357     } catch (std::exception& e) {
40358       {
40359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40360       };
40361     } catch (Dali::DaliException e) {
40362       {
40363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40364       };
40365     } catch (...) {
40366       {
40367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40368       };
40369     }
40370   }
40371
40372   jresult = (void *)result;
40373   return jresult;
40374 }
40375
40376
40377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40378   void * jresult ;
40379   Dali::CustomActorImpl *arg1 = 0 ;
40380   Dali::CustomActor *result = 0 ;
40381
40382   arg1 = (Dali::CustomActorImpl *)jarg1;
40383   if (!arg1) {
40384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40385     return 0;
40386   }
40387   {
40388     try {
40389       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40390     } catch (std::out_of_range& e) {
40391       {
40392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40393       };
40394     } catch (std::exception& e) {
40395       {
40396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40397       };
40398     } catch (Dali::DaliException e) {
40399       {
40400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40401       };
40402     } catch (...) {
40403       {
40404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40405       };
40406     }
40407   }
40408
40409   jresult = (void *)result;
40410   return jresult;
40411 }
40412
40413
40414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40415   void * jresult ;
40416   Dali::CustomActor *arg1 = 0 ;
40417   Dali::CustomActor *result = 0 ;
40418
40419   arg1 = (Dali::CustomActor *)jarg1;
40420   if (!arg1) {
40421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40422     return 0;
40423   }
40424   {
40425     try {
40426       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40427     } catch (std::out_of_range& e) {
40428       {
40429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (std::exception& e) {
40432       {
40433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40434       };
40435     } catch (Dali::DaliException e) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40438       };
40439     } catch (...) {
40440       {
40441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40442       };
40443     }
40444   }
40445
40446   jresult = (void *)result;
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40452   void * jresult ;
40453   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40454   Dali::CustomActor *arg2 = 0 ;
40455   Dali::CustomActor *result = 0 ;
40456
40457   arg1 = (Dali::CustomActor *)jarg1;
40458   arg2 = (Dali::CustomActor *)jarg2;
40459   if (!arg2) {
40460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40461     return 0;
40462   }
40463   {
40464     try {
40465       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40466     } catch (std::out_of_range& e) {
40467       {
40468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40469       };
40470     } catch (std::exception& e) {
40471       {
40472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40473       };
40474     } catch (Dali::DaliException e) {
40475       {
40476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40477       };
40478     } catch (...) {
40479       {
40480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40481       };
40482     }
40483   }
40484
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40491   int jresult ;
40492   int result;
40493
40494   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40495   jresult = (int)result;
40496   return jresult;
40497 }
40498
40499
40500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40501   int jresult ;
40502   int result;
40503
40504   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40505   jresult = (int)result;
40506   return jresult;
40507 }
40508
40509
40510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40511   int jresult ;
40512   int result;
40513
40514   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40515   jresult = (int)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40521   int jresult ;
40522   int result;
40523
40524   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40525   jresult = (int)result;
40526   return jresult;
40527 }
40528
40529
40530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40531   int jresult ;
40532   int result;
40533
40534   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40535   jresult = (int)result;
40536   return jresult;
40537 }
40538
40539
40540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40541   int jresult ;
40542   int result;
40543
40544   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40545   jresult = (int)result;
40546   return jresult;
40547 }
40548
40549
40550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40551   int jresult ;
40552   int result;
40553
40554   result = (int)Dali::PanGestureDetector::Property::PANNING;
40555   jresult = (int)result;
40556   return jresult;
40557 }
40558
40559
40560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40561   void * jresult ;
40562   Dali::PanGestureDetector::Property *result = 0 ;
40563
40564   {
40565     try {
40566       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40567     } catch (std::out_of_range& e) {
40568       {
40569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (std::exception& e) {
40572       {
40573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40574       };
40575     } catch (Dali::DaliException e) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40578       };
40579     } catch (...) {
40580       {
40581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40582       };
40583     }
40584   }
40585
40586   jresult = (void *)result;
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40592   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40593
40594   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40595   {
40596     try {
40597       delete arg1;
40598     } catch (std::out_of_range& e) {
40599       {
40600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40601       };
40602     } catch (std::exception& e) {
40603       {
40604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40605       };
40606     } catch (Dali::DaliException e) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40609       };
40610     } catch (...) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40613       };
40614     }
40615   }
40616
40617 }
40618
40619
40620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40621   void * jresult ;
40622   Dali::Radian *result = 0 ;
40623
40624   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40625   jresult = (void *)result;
40626   return jresult;
40627 }
40628
40629
40630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40631   void * jresult ;
40632   Dali::Radian *result = 0 ;
40633
40634   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40635   jresult = (void *)result;
40636   return jresult;
40637 }
40638
40639
40640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40641   void * jresult ;
40642   Dali::Radian *result = 0 ;
40643
40644   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40645   jresult = (void *)result;
40646   return jresult;
40647 }
40648
40649
40650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40651   void * jresult ;
40652   Dali::Radian *result = 0 ;
40653
40654   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40655   jresult = (void *)result;
40656   return jresult;
40657 }
40658
40659
40660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40661   void * jresult ;
40662   Dali::Radian *result = 0 ;
40663
40664   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40665   jresult = (void *)result;
40666   return jresult;
40667 }
40668
40669
40670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40671   void * jresult ;
40672   Dali::Radian *result = 0 ;
40673
40674   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40675   jresult = (void *)result;
40676   return jresult;
40677 }
40678
40679
40680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40681   void * jresult ;
40682   Dali::Radian *result = 0 ;
40683
40684   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40685   jresult = (void *)result;
40686   return jresult;
40687 }
40688
40689
40690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40691   void * jresult ;
40692   Dali::PanGestureDetector *result = 0 ;
40693
40694   {
40695     try {
40696       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40697     } catch (std::out_of_range& e) {
40698       {
40699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40700       };
40701     } catch (std::exception& e) {
40702       {
40703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40704       };
40705     } catch (Dali::DaliException e) {
40706       {
40707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40708       };
40709     } catch (...) {
40710       {
40711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40712       };
40713     }
40714   }
40715
40716   jresult = (void *)result;
40717   return jresult;
40718 }
40719
40720
40721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40722   void * jresult ;
40723   Dali::PanGestureDetector result;
40724
40725   {
40726     try {
40727       result = Dali::PanGestureDetector::New();
40728     } catch (std::out_of_range& e) {
40729       {
40730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40731       };
40732     } catch (std::exception& e) {
40733       {
40734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40735       };
40736     } catch (Dali::DaliException e) {
40737       {
40738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40739       };
40740     } catch (...) {
40741       {
40742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40743       };
40744     }
40745   }
40746
40747   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40748   return jresult;
40749 }
40750
40751
40752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40753   void * jresult ;
40754   Dali::BaseHandle arg1 ;
40755   Dali::BaseHandle *argp1 ;
40756   Dali::PanGestureDetector result;
40757
40758   argp1 = (Dali::BaseHandle *)jarg1;
40759   if (!argp1) {
40760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40761     return 0;
40762   }
40763   arg1 = *argp1;
40764   {
40765     try {
40766       result = Dali::PanGestureDetector::DownCast(arg1);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40774       };
40775     } catch (Dali::DaliException e) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40778       };
40779     } catch (...) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40782       };
40783     }
40784   }
40785
40786   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40792   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40793
40794   arg1 = (Dali::PanGestureDetector *)jarg1;
40795   {
40796     try {
40797       delete arg1;
40798     } catch (std::out_of_range& e) {
40799       {
40800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40801       };
40802     } catch (std::exception& e) {
40803       {
40804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40805       };
40806     } catch (Dali::DaliException e) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40809       };
40810     } catch (...) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40813       };
40814     }
40815   }
40816
40817 }
40818
40819
40820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40821   void * jresult ;
40822   Dali::PanGestureDetector *arg1 = 0 ;
40823   Dali::PanGestureDetector *result = 0 ;
40824
40825   arg1 = (Dali::PanGestureDetector *)jarg1;
40826   if (!arg1) {
40827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40828     return 0;
40829   }
40830   {
40831     try {
40832       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40833     } catch (std::out_of_range& e) {
40834       {
40835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40836       };
40837     } catch (std::exception& e) {
40838       {
40839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40840       };
40841     } catch (Dali::DaliException e) {
40842       {
40843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40844       };
40845     } catch (...) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40848       };
40849     }
40850   }
40851
40852   jresult = (void *)result;
40853   return jresult;
40854 }
40855
40856
40857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40858   void * jresult ;
40859   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40860   Dali::PanGestureDetector *arg2 = 0 ;
40861   Dali::PanGestureDetector *result = 0 ;
40862
40863   arg1 = (Dali::PanGestureDetector *)jarg1;
40864   arg2 = (Dali::PanGestureDetector *)jarg2;
40865   if (!arg2) {
40866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40867     return 0;
40868   }
40869   {
40870     try {
40871       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40872     } catch (std::out_of_range& e) {
40873       {
40874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40875       };
40876     } catch (std::exception& e) {
40877       {
40878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40879       };
40880     } catch (Dali::DaliException e) {
40881       {
40882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40883       };
40884     } catch (...) {
40885       {
40886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40887       };
40888     }
40889   }
40890
40891   jresult = (void *)result;
40892   return jresult;
40893 }
40894
40895
40896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40897   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40898   unsigned int arg2 ;
40899
40900   arg1 = (Dali::PanGestureDetector *)jarg1;
40901   arg2 = (unsigned int)jarg2;
40902   {
40903     try {
40904       (arg1)->SetMinimumTouchesRequired(arg2);
40905     } catch (std::out_of_range& e) {
40906       {
40907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40908       };
40909     } catch (std::exception& e) {
40910       {
40911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40912       };
40913     } catch (Dali::DaliException e) {
40914       {
40915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40916       };
40917     } catch (...) {
40918       {
40919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40920       };
40921     }
40922   }
40923
40924 }
40925
40926
40927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40928   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40929   unsigned int arg2 ;
40930
40931   arg1 = (Dali::PanGestureDetector *)jarg1;
40932   arg2 = (unsigned int)jarg2;
40933   {
40934     try {
40935       (arg1)->SetMaximumTouchesRequired(arg2);
40936     } catch (std::out_of_range& e) {
40937       {
40938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40939       };
40940     } catch (std::exception& e) {
40941       {
40942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40943       };
40944     } catch (Dali::DaliException e) {
40945       {
40946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40947       };
40948     } catch (...) {
40949       {
40950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40951       };
40952     }
40953   }
40954
40955 }
40956
40957
40958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40959   unsigned int jresult ;
40960   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40961   unsigned int result;
40962
40963   arg1 = (Dali::PanGestureDetector *)jarg1;
40964   {
40965     try {
40966       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40967     } catch (std::out_of_range& e) {
40968       {
40969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40970       };
40971     } catch (std::exception& e) {
40972       {
40973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40974       };
40975     } catch (Dali::DaliException e) {
40976       {
40977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40982       };
40983     }
40984   }
40985
40986   jresult = result;
40987   return jresult;
40988 }
40989
40990
40991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40992   unsigned int jresult ;
40993   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40994   unsigned int result;
40995
40996   arg1 = (Dali::PanGestureDetector *)jarg1;
40997   {
40998     try {
40999       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
41000     } catch (std::out_of_range& e) {
41001       {
41002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41003       };
41004     } catch (std::exception& e) {
41005       {
41006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41007       };
41008     } catch (Dali::DaliException e) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41011       };
41012     } catch (...) {
41013       {
41014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41015       };
41016     }
41017   }
41018
41019   jresult = result;
41020   return jresult;
41021 }
41022
41023
41024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41026   Dali::Radian arg2 ;
41027   Dali::Radian arg3 ;
41028   Dali::Radian *argp2 ;
41029   Dali::Radian *argp3 ;
41030
41031   arg1 = (Dali::PanGestureDetector *)jarg1;
41032   argp2 = (Dali::Radian *)jarg2;
41033   if (!argp2) {
41034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41035     return ;
41036   }
41037   arg2 = *argp2;
41038   argp3 = (Dali::Radian *)jarg3;
41039   if (!argp3) {
41040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41041     return ;
41042   }
41043   arg3 = *argp3;
41044   {
41045     try {
41046       (arg1)->AddAngle(arg2,arg3);
41047     } catch (std::out_of_range& e) {
41048       {
41049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41050       };
41051     } catch (std::exception& e) {
41052       {
41053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41054       };
41055     } catch (Dali::DaliException e) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41058       };
41059     } catch (...) {
41060       {
41061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41062       };
41063     }
41064   }
41065
41066 }
41067
41068
41069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41070   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41071   Dali::Radian arg2 ;
41072   Dali::Radian *argp2 ;
41073
41074   arg1 = (Dali::PanGestureDetector *)jarg1;
41075   argp2 = (Dali::Radian *)jarg2;
41076   if (!argp2) {
41077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41078     return ;
41079   }
41080   arg2 = *argp2;
41081   {
41082     try {
41083       (arg1)->AddAngle(arg2);
41084     } catch (std::out_of_range& e) {
41085       {
41086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41087       };
41088     } catch (std::exception& e) {
41089       {
41090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41091       };
41092     } catch (Dali::DaliException e) {
41093       {
41094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41095       };
41096     } catch (...) {
41097       {
41098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41099       };
41100     }
41101   }
41102
41103 }
41104
41105
41106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41107   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41108   Dali::Radian arg2 ;
41109   Dali::Radian arg3 ;
41110   Dali::Radian *argp2 ;
41111   Dali::Radian *argp3 ;
41112
41113   arg1 = (Dali::PanGestureDetector *)jarg1;
41114   argp2 = (Dali::Radian *)jarg2;
41115   if (!argp2) {
41116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41117     return ;
41118   }
41119   arg2 = *argp2;
41120   argp3 = (Dali::Radian *)jarg3;
41121   if (!argp3) {
41122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41123     return ;
41124   }
41125   arg3 = *argp3;
41126   {
41127     try {
41128       (arg1)->AddDirection(arg2,arg3);
41129     } catch (std::out_of_range& e) {
41130       {
41131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41132       };
41133     } catch (std::exception& e) {
41134       {
41135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41136       };
41137     } catch (Dali::DaliException e) {
41138       {
41139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41140       };
41141     } catch (...) {
41142       {
41143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41144       };
41145     }
41146   }
41147
41148 }
41149
41150
41151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41152   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41153   Dali::Radian arg2 ;
41154   Dali::Radian *argp2 ;
41155
41156   arg1 = (Dali::PanGestureDetector *)jarg1;
41157   argp2 = (Dali::Radian *)jarg2;
41158   if (!argp2) {
41159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41160     return ;
41161   }
41162   arg2 = *argp2;
41163   {
41164     try {
41165       (arg1)->AddDirection(arg2);
41166     } catch (std::out_of_range& e) {
41167       {
41168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41169       };
41170     } catch (std::exception& e) {
41171       {
41172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41173       };
41174     } catch (Dali::DaliException e) {
41175       {
41176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41177       };
41178     } catch (...) {
41179       {
41180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41181       };
41182     }
41183   }
41184
41185 }
41186
41187
41188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41189   unsigned long jresult ;
41190   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41191   size_t result;
41192
41193   arg1 = (Dali::PanGestureDetector *)jarg1;
41194   {
41195     try {
41196       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41197     } catch (std::out_of_range& e) {
41198       {
41199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (std::exception& e) {
41202       {
41203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41204       };
41205     } catch (Dali::DaliException e) {
41206       {
41207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41208       };
41209     } catch (...) {
41210       {
41211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41212       };
41213     }
41214   }
41215
41216   jresult = (unsigned long)result;
41217   return jresult;
41218 }
41219
41220
41221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41222   void * jresult ;
41223   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41224   size_t arg2 ;
41225   Dali::PanGestureDetector::AngleThresholdPair result;
41226
41227   arg1 = (Dali::PanGestureDetector *)jarg1;
41228   arg2 = (size_t)jarg2;
41229   {
41230     try {
41231       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41232     } catch (std::out_of_range& e) {
41233       {
41234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41235       };
41236     } catch (std::exception& e) {
41237       {
41238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41239       };
41240     } catch (Dali::DaliException e) {
41241       {
41242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41243       };
41244     } catch (...) {
41245       {
41246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41247       };
41248     }
41249   }
41250
41251   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41252   return jresult;
41253 }
41254
41255
41256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41257   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41258
41259   arg1 = (Dali::PanGestureDetector *)jarg1;
41260   {
41261     try {
41262       (arg1)->ClearAngles();
41263     } catch (std::out_of_range& e) {
41264       {
41265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41266       };
41267     } catch (std::exception& e) {
41268       {
41269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41270       };
41271     } catch (Dali::DaliException e) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41274       };
41275     } catch (...) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41278       };
41279     }
41280   }
41281
41282 }
41283
41284
41285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41286   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41287   Dali::Radian arg2 ;
41288   Dali::Radian *argp2 ;
41289
41290   arg1 = (Dali::PanGestureDetector *)jarg1;
41291   argp2 = (Dali::Radian *)jarg2;
41292   if (!argp2) {
41293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41294     return ;
41295   }
41296   arg2 = *argp2;
41297   {
41298     try {
41299       (arg1)->RemoveAngle(arg2);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41307       };
41308     } catch (Dali::DaliException e) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41311       };
41312     } catch (...) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41315       };
41316     }
41317   }
41318
41319 }
41320
41321
41322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41323   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41324   Dali::Radian arg2 ;
41325   Dali::Radian *argp2 ;
41326
41327   arg1 = (Dali::PanGestureDetector *)jarg1;
41328   argp2 = (Dali::Radian *)jarg2;
41329   if (!argp2) {
41330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41331     return ;
41332   }
41333   arg2 = *argp2;
41334   {
41335     try {
41336       (arg1)->RemoveDirection(arg2);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41344       };
41345     } catch (Dali::DaliException e) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41352       };
41353     }
41354   }
41355
41356 }
41357
41358
41359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41360   void * jresult ;
41361   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41362   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41363
41364   arg1 = (Dali::PanGestureDetector *)jarg1;
41365   {
41366     try {
41367       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41368     } catch (std::out_of_range& e) {
41369       {
41370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41371       };
41372     } catch (std::exception& e) {
41373       {
41374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41375       };
41376     } catch (Dali::DaliException e) {
41377       {
41378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41379       };
41380     } catch (...) {
41381       {
41382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41383       };
41384     }
41385   }
41386
41387   jresult = (void *)result;
41388   return jresult;
41389 }
41390
41391
41392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41393   Dali::PanGesture *arg1 = 0 ;
41394
41395   arg1 = (Dali::PanGesture *)jarg1;
41396   if (!arg1) {
41397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41398     return ;
41399   }
41400   {
41401     try {
41402       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41403     } catch (std::out_of_range& e) {
41404       {
41405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41406       };
41407     } catch (std::exception& e) {
41408       {
41409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (Dali::DaliException e) {
41412       {
41413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41414       };
41415     } catch (...) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41418       };
41419     }
41420   }
41421
41422 }
41423
41424
41425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41426   void * jresult ;
41427   Dali::PanGesture *result = 0 ;
41428
41429   {
41430     try {
41431       result = (Dali::PanGesture *)new Dali::PanGesture();
41432     } catch (std::out_of_range& e) {
41433       {
41434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (std::exception& e) {
41437       {
41438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41439       };
41440     } catch (Dali::DaliException e) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41443       };
41444     } catch (...) {
41445       {
41446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41447       };
41448     }
41449   }
41450
41451   jresult = (void *)result;
41452   return jresult;
41453 }
41454
41455
41456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41457   void * jresult ;
41458   Dali::Gesture::State arg1 ;
41459   Dali::PanGesture *result = 0 ;
41460
41461   arg1 = (Dali::Gesture::State)jarg1;
41462   {
41463     try {
41464       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41465     } catch (std::out_of_range& e) {
41466       {
41467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (std::exception& e) {
41470       {
41471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41472       };
41473     } catch (Dali::DaliException e) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41476       };
41477     } catch (...) {
41478       {
41479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41480       };
41481     }
41482   }
41483
41484   jresult = (void *)result;
41485   return jresult;
41486 }
41487
41488
41489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41490   void * jresult ;
41491   Dali::PanGesture *arg1 = 0 ;
41492   Dali::PanGesture *result = 0 ;
41493
41494   arg1 = (Dali::PanGesture *)jarg1;
41495   if (!arg1) {
41496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41497     return 0;
41498   }
41499   {
41500     try {
41501       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41502     } catch (std::out_of_range& e) {
41503       {
41504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (std::exception& e) {
41507       {
41508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41509       };
41510     } catch (Dali::DaliException e) {
41511       {
41512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41513       };
41514     } catch (...) {
41515       {
41516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41517       };
41518     }
41519   }
41520
41521   jresult = (void *)result;
41522   return jresult;
41523 }
41524
41525
41526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41527   void * jresult ;
41528   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41529   Dali::PanGesture *arg2 = 0 ;
41530   Dali::PanGesture *result = 0 ;
41531
41532   arg1 = (Dali::PanGesture *)jarg1;
41533   arg2 = (Dali::PanGesture *)jarg2;
41534   if (!arg2) {
41535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41536     return 0;
41537   }
41538   {
41539     try {
41540       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41541     } catch (std::out_of_range& e) {
41542       {
41543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41544       };
41545     } catch (std::exception& e) {
41546       {
41547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41548       };
41549     } catch (Dali::DaliException e) {
41550       {
41551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41552       };
41553     } catch (...) {
41554       {
41555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41556       };
41557     }
41558   }
41559
41560   jresult = (void *)result;
41561   return jresult;
41562 }
41563
41564
41565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41566   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41567
41568   arg1 = (Dali::PanGesture *)jarg1;
41569   {
41570     try {
41571       delete arg1;
41572     } catch (std::out_of_range& e) {
41573       {
41574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41575       };
41576     } catch (std::exception& e) {
41577       {
41578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41579       };
41580     } catch (Dali::DaliException e) {
41581       {
41582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41583       };
41584     } catch (...) {
41585       {
41586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41587       };
41588     }
41589   }
41590
41591 }
41592
41593
41594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41595   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41596   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41597
41598   arg1 = (Dali::PanGesture *)jarg1;
41599   arg2 = (Dali::Vector2 *)jarg2;
41600   if (arg1) (arg1)->velocity = *arg2;
41601 }
41602
41603
41604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41605   void * jresult ;
41606   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41607   Dali::Vector2 *result = 0 ;
41608
41609   arg1 = (Dali::PanGesture *)jarg1;
41610   result = (Dali::Vector2 *)& ((arg1)->velocity);
41611   jresult = (void *)result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41617   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41618   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41619
41620   arg1 = (Dali::PanGesture *)jarg1;
41621   arg2 = (Dali::Vector2 *)jarg2;
41622   if (arg1) (arg1)->displacement = *arg2;
41623 }
41624
41625
41626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41627   void * jresult ;
41628   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41629   Dali::Vector2 *result = 0 ;
41630
41631   arg1 = (Dali::PanGesture *)jarg1;
41632   result = (Dali::Vector2 *)& ((arg1)->displacement);
41633   jresult = (void *)result;
41634   return jresult;
41635 }
41636
41637
41638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41639   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41640   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41641
41642   arg1 = (Dali::PanGesture *)jarg1;
41643   arg2 = (Dali::Vector2 *)jarg2;
41644   if (arg1) (arg1)->position = *arg2;
41645 }
41646
41647
41648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41649   void * jresult ;
41650   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41651   Dali::Vector2 *result = 0 ;
41652
41653   arg1 = (Dali::PanGesture *)jarg1;
41654   result = (Dali::Vector2 *)& ((arg1)->position);
41655   jresult = (void *)result;
41656   return jresult;
41657 }
41658
41659
41660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41661   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41662   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41663
41664   arg1 = (Dali::PanGesture *)jarg1;
41665   arg2 = (Dali::Vector2 *)jarg2;
41666   if (arg1) (arg1)->screenVelocity = *arg2;
41667 }
41668
41669
41670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41671   void * jresult ;
41672   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41673   Dali::Vector2 *result = 0 ;
41674
41675   arg1 = (Dali::PanGesture *)jarg1;
41676   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41677   jresult = (void *)result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41683   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41684   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41685
41686   arg1 = (Dali::PanGesture *)jarg1;
41687   arg2 = (Dali::Vector2 *)jarg2;
41688   if (arg1) (arg1)->screenDisplacement = *arg2;
41689 }
41690
41691
41692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41693   void * jresult ;
41694   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41695   Dali::Vector2 *result = 0 ;
41696
41697   arg1 = (Dali::PanGesture *)jarg1;
41698   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41699   jresult = (void *)result;
41700   return jresult;
41701 }
41702
41703
41704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41705   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41707
41708   arg1 = (Dali::PanGesture *)jarg1;
41709   arg2 = (Dali::Vector2 *)jarg2;
41710   if (arg1) (arg1)->screenPosition = *arg2;
41711 }
41712
41713
41714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41715   void * jresult ;
41716   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41717   Dali::Vector2 *result = 0 ;
41718
41719   arg1 = (Dali::PanGesture *)jarg1;
41720   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41721   jresult = (void *)result;
41722   return jresult;
41723 }
41724
41725
41726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41727   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41728   unsigned int arg2 ;
41729
41730   arg1 = (Dali::PanGesture *)jarg1;
41731   arg2 = (unsigned int)jarg2;
41732   if (arg1) (arg1)->numberOfTouches = arg2;
41733 }
41734
41735
41736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41737   unsigned int jresult ;
41738   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41739   unsigned int result;
41740
41741   arg1 = (Dali::PanGesture *)jarg1;
41742   result = (unsigned int) ((arg1)->numberOfTouches);
41743   jresult = result;
41744   return jresult;
41745 }
41746
41747
41748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41749   float jresult ;
41750   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41751   float result;
41752
41753   arg1 = (Dali::PanGesture *)jarg1;
41754   {
41755     try {
41756       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41757     } catch (std::out_of_range& e) {
41758       {
41759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (std::exception& e) {
41762       {
41763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41764       };
41765     } catch (Dali::DaliException e) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41768       };
41769     } catch (...) {
41770       {
41771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41772       };
41773     }
41774   }
41775
41776   jresult = result;
41777   return jresult;
41778 }
41779
41780
41781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41782   float jresult ;
41783   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41784   float result;
41785
41786   arg1 = (Dali::PanGesture *)jarg1;
41787   {
41788     try {
41789       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41790     } catch (std::out_of_range& e) {
41791       {
41792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (std::exception& e) {
41795       {
41796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (Dali::DaliException e) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41801       };
41802     } catch (...) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41805       };
41806     }
41807   }
41808
41809   jresult = result;
41810   return jresult;
41811 }
41812
41813
41814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41815   float jresult ;
41816   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41817   float result;
41818
41819   arg1 = (Dali::PanGesture *)jarg1;
41820   {
41821     try {
41822       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41823     } catch (std::out_of_range& e) {
41824       {
41825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41826       };
41827     } catch (std::exception& e) {
41828       {
41829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41830       };
41831     } catch (Dali::DaliException e) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41838       };
41839     }
41840   }
41841
41842   jresult = result;
41843   return jresult;
41844 }
41845
41846
41847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41848   float jresult ;
41849   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41850   float result;
41851
41852   arg1 = (Dali::PanGesture *)jarg1;
41853   {
41854     try {
41855       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41856     } catch (std::out_of_range& e) {
41857       {
41858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41859       };
41860     } catch (std::exception& e) {
41861       {
41862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (Dali::DaliException e) {
41865       {
41866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41867       };
41868     } catch (...) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41871       };
41872     }
41873   }
41874
41875   jresult = result;
41876   return jresult;
41877 }
41878
41879
41880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41881   void * jresult ;
41882   Dali::PinchGestureDetector *result = 0 ;
41883
41884   {
41885     try {
41886       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41887     } catch (std::out_of_range& e) {
41888       {
41889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41890       };
41891     } catch (std::exception& e) {
41892       {
41893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41894       };
41895     } catch (Dali::DaliException e) {
41896       {
41897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41898       };
41899     } catch (...) {
41900       {
41901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41902       };
41903     }
41904   }
41905
41906   jresult = (void *)result;
41907   return jresult;
41908 }
41909
41910
41911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41912   void * jresult ;
41913   Dali::PinchGestureDetector result;
41914
41915   {
41916     try {
41917       result = Dali::PinchGestureDetector::New();
41918     } catch (std::out_of_range& e) {
41919       {
41920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (std::exception& e) {
41923       {
41924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41925       };
41926     } catch (Dali::DaliException e) {
41927       {
41928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41929       };
41930     } catch (...) {
41931       {
41932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41933       };
41934     }
41935   }
41936
41937   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41938   return jresult;
41939 }
41940
41941
41942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41943   void * jresult ;
41944   Dali::BaseHandle arg1 ;
41945   Dali::BaseHandle *argp1 ;
41946   Dali::PinchGestureDetector result;
41947
41948   argp1 = (Dali::BaseHandle *)jarg1;
41949   if (!argp1) {
41950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41951     return 0;
41952   }
41953   arg1 = *argp1;
41954   {
41955     try {
41956       result = Dali::PinchGestureDetector::DownCast(arg1);
41957     } catch (std::out_of_range& e) {
41958       {
41959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41960       };
41961     } catch (std::exception& e) {
41962       {
41963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (Dali::DaliException e) {
41966       {
41967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41968       };
41969     } catch (...) {
41970       {
41971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41972       };
41973     }
41974   }
41975
41976   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41977   return jresult;
41978 }
41979
41980
41981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41982   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41983
41984   arg1 = (Dali::PinchGestureDetector *)jarg1;
41985   {
41986     try {
41987       delete arg1;
41988     } catch (std::out_of_range& e) {
41989       {
41990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41991       };
41992     } catch (std::exception& e) {
41993       {
41994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41995       };
41996     } catch (Dali::DaliException e) {
41997       {
41998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41999       };
42000     } catch (...) {
42001       {
42002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42003       };
42004     }
42005   }
42006
42007 }
42008
42009
42010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42011   void * jresult ;
42012   Dali::PinchGestureDetector *arg1 = 0 ;
42013   Dali::PinchGestureDetector *result = 0 ;
42014
42015   arg1 = (Dali::PinchGestureDetector *)jarg1;
42016   if (!arg1) {
42017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42018     return 0;
42019   }
42020   {
42021     try {
42022       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42023     } catch (std::out_of_range& e) {
42024       {
42025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42026       };
42027     } catch (std::exception& e) {
42028       {
42029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42030       };
42031     } catch (Dali::DaliException e) {
42032       {
42033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42034       };
42035     } catch (...) {
42036       {
42037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42038       };
42039     }
42040   }
42041
42042   jresult = (void *)result;
42043   return jresult;
42044 }
42045
42046
42047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42048   void * jresult ;
42049   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42050   Dali::PinchGestureDetector *arg2 = 0 ;
42051   Dali::PinchGestureDetector *result = 0 ;
42052
42053   arg1 = (Dali::PinchGestureDetector *)jarg1;
42054   arg2 = (Dali::PinchGestureDetector *)jarg2;
42055   if (!arg2) {
42056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42057     return 0;
42058   }
42059   {
42060     try {
42061       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42062     } catch (std::out_of_range& e) {
42063       {
42064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42065       };
42066     } catch (std::exception& e) {
42067       {
42068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42069       };
42070     } catch (Dali::DaliException e) {
42071       {
42072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42073       };
42074     } catch (...) {
42075       {
42076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42077       };
42078     }
42079   }
42080
42081   jresult = (void *)result;
42082   return jresult;
42083 }
42084
42085
42086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42087   void * jresult ;
42088   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42089   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42090
42091   arg1 = (Dali::PinchGestureDetector *)jarg1;
42092   {
42093     try {
42094       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42095     } catch (std::out_of_range& e) {
42096       {
42097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (std::exception& e) {
42100       {
42101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42102       };
42103     } catch (Dali::DaliException e) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42106       };
42107     } catch (...) {
42108       {
42109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42110       };
42111     }
42112   }
42113
42114   jresult = (void *)result;
42115   return jresult;
42116 }
42117
42118
42119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42120   void * jresult ;
42121   Dali::Gesture::State arg1 ;
42122   Dali::PinchGesture *result = 0 ;
42123
42124   arg1 = (Dali::Gesture::State)jarg1;
42125   {
42126     try {
42127       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42128     } catch (std::out_of_range& e) {
42129       {
42130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (std::exception& e) {
42133       {
42134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42135       };
42136     } catch (Dali::DaliException e) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42139       };
42140     } catch (...) {
42141       {
42142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42143       };
42144     }
42145   }
42146
42147   jresult = (void *)result;
42148   return jresult;
42149 }
42150
42151
42152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42153   void * jresult ;
42154   Dali::PinchGesture *arg1 = 0 ;
42155   Dali::PinchGesture *result = 0 ;
42156
42157   arg1 = (Dali::PinchGesture *)jarg1;
42158   if (!arg1) {
42159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42160     return 0;
42161   }
42162   {
42163     try {
42164       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42165     } catch (std::out_of_range& e) {
42166       {
42167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42168       };
42169     } catch (std::exception& e) {
42170       {
42171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42172       };
42173     } catch (Dali::DaliException e) {
42174       {
42175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42176       };
42177     } catch (...) {
42178       {
42179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42180       };
42181     }
42182   }
42183
42184   jresult = (void *)result;
42185   return jresult;
42186 }
42187
42188
42189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42190   void * jresult ;
42191   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42192   Dali::PinchGesture *arg2 = 0 ;
42193   Dali::PinchGesture *result = 0 ;
42194
42195   arg1 = (Dali::PinchGesture *)jarg1;
42196   arg2 = (Dali::PinchGesture *)jarg2;
42197   if (!arg2) {
42198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42199     return 0;
42200   }
42201   {
42202     try {
42203       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42204     } catch (std::out_of_range& e) {
42205       {
42206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42207       };
42208     } catch (std::exception& e) {
42209       {
42210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42211       };
42212     } catch (Dali::DaliException e) {
42213       {
42214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42215       };
42216     } catch (...) {
42217       {
42218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42219       };
42220     }
42221   }
42222
42223   jresult = (void *)result;
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42229   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42230
42231   arg1 = (Dali::PinchGesture *)jarg1;
42232   {
42233     try {
42234       delete arg1;
42235     } catch (std::out_of_range& e) {
42236       {
42237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42238       };
42239     } catch (std::exception& e) {
42240       {
42241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42242       };
42243     } catch (Dali::DaliException e) {
42244       {
42245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42246       };
42247     } catch (...) {
42248       {
42249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42250       };
42251     }
42252   }
42253
42254 }
42255
42256
42257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42258   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42259   float arg2 ;
42260
42261   arg1 = (Dali::PinchGesture *)jarg1;
42262   arg2 = (float)jarg2;
42263   if (arg1) (arg1)->scale = arg2;
42264 }
42265
42266
42267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42268   float jresult ;
42269   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42270   float result;
42271
42272   arg1 = (Dali::PinchGesture *)jarg1;
42273   result = (float) ((arg1)->scale);
42274   jresult = result;
42275   return jresult;
42276 }
42277
42278
42279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42280   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42281   float arg2 ;
42282
42283   arg1 = (Dali::PinchGesture *)jarg1;
42284   arg2 = (float)jarg2;
42285   if (arg1) (arg1)->speed = arg2;
42286 }
42287
42288
42289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42290   float jresult ;
42291   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42292   float result;
42293
42294   arg1 = (Dali::PinchGesture *)jarg1;
42295   result = (float) ((arg1)->speed);
42296   jresult = result;
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42302   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42303   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42304
42305   arg1 = (Dali::PinchGesture *)jarg1;
42306   arg2 = (Dali::Vector2 *)jarg2;
42307   if (arg1) (arg1)->screenCenterPoint = *arg2;
42308 }
42309
42310
42311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42312   void * jresult ;
42313   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42314   Dali::Vector2 *result = 0 ;
42315
42316   arg1 = (Dali::PinchGesture *)jarg1;
42317   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42318   jresult = (void *)result;
42319   return jresult;
42320 }
42321
42322
42323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42324   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42325   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42326
42327   arg1 = (Dali::PinchGesture *)jarg1;
42328   arg2 = (Dali::Vector2 *)jarg2;
42329   if (arg1) (arg1)->localCenterPoint = *arg2;
42330 }
42331
42332
42333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42334   void * jresult ;
42335   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42336   Dali::Vector2 *result = 0 ;
42337
42338   arg1 = (Dali::PinchGesture *)jarg1;
42339   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42340   jresult = (void *)result;
42341   return jresult;
42342 }
42343
42344
42345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42346   void * jresult ;
42347   Dali::TapGestureDetector *result = 0 ;
42348
42349   {
42350     try {
42351       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42352     } catch (std::out_of_range& e) {
42353       {
42354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42355       };
42356     } catch (std::exception& e) {
42357       {
42358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (Dali::DaliException e) {
42361       {
42362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42363       };
42364     } catch (...) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42367       };
42368     }
42369   }
42370
42371   jresult = (void *)result;
42372   return jresult;
42373 }
42374
42375
42376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42377   void * jresult ;
42378   Dali::TapGestureDetector result;
42379
42380   {
42381     try {
42382       result = Dali::TapGestureDetector::New();
42383     } catch (std::out_of_range& e) {
42384       {
42385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42386       };
42387     } catch (std::exception& e) {
42388       {
42389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42390       };
42391     } catch (Dali::DaliException e) {
42392       {
42393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42394       };
42395     } catch (...) {
42396       {
42397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42398       };
42399     }
42400   }
42401
42402   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42403   return jresult;
42404 }
42405
42406
42407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42408   void * jresult ;
42409   unsigned int arg1 ;
42410   Dali::TapGestureDetector result;
42411
42412   arg1 = (unsigned int)jarg1;
42413   {
42414     try {
42415       result = Dali::TapGestureDetector::New(arg1);
42416     } catch (std::out_of_range& e) {
42417       {
42418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42419       };
42420     } catch (std::exception& e) {
42421       {
42422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (Dali::DaliException e) {
42425       {
42426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42427       };
42428     } catch (...) {
42429       {
42430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42431       };
42432     }
42433   }
42434
42435   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42436   return jresult;
42437 }
42438
42439
42440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42441   void * jresult ;
42442   Dali::BaseHandle arg1 ;
42443   Dali::BaseHandle *argp1 ;
42444   Dali::TapGestureDetector result;
42445
42446   argp1 = (Dali::BaseHandle *)jarg1;
42447   if (!argp1) {
42448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42449     return 0;
42450   }
42451   arg1 = *argp1;
42452   {
42453     try {
42454       result = Dali::TapGestureDetector::DownCast(arg1);
42455     } catch (std::out_of_range& e) {
42456       {
42457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42458       };
42459     } catch (std::exception& e) {
42460       {
42461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42462       };
42463     } catch (Dali::DaliException e) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42466       };
42467     } catch (...) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42470       };
42471     }
42472   }
42473
42474   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42475   return jresult;
42476 }
42477
42478
42479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42480   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42481
42482   arg1 = (Dali::TapGestureDetector *)jarg1;
42483   {
42484     try {
42485       delete arg1;
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42493       };
42494     } catch (Dali::DaliException e) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42497       };
42498     } catch (...) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42501       };
42502     }
42503   }
42504
42505 }
42506
42507
42508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42509   void * jresult ;
42510   Dali::TapGestureDetector *arg1 = 0 ;
42511   Dali::TapGestureDetector *result = 0 ;
42512
42513   arg1 = (Dali::TapGestureDetector *)jarg1;
42514   if (!arg1) {
42515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42516     return 0;
42517   }
42518   {
42519     try {
42520       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42521     } catch (std::out_of_range& e) {
42522       {
42523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42524       };
42525     } catch (std::exception& e) {
42526       {
42527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42528       };
42529     } catch (Dali::DaliException e) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42532       };
42533     } catch (...) {
42534       {
42535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42536       };
42537     }
42538   }
42539
42540   jresult = (void *)result;
42541   return jresult;
42542 }
42543
42544
42545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42546   void * jresult ;
42547   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42548   Dali::TapGestureDetector *arg2 = 0 ;
42549   Dali::TapGestureDetector *result = 0 ;
42550
42551   arg1 = (Dali::TapGestureDetector *)jarg1;
42552   arg2 = (Dali::TapGestureDetector *)jarg2;
42553   if (!arg2) {
42554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42555     return 0;
42556   }
42557   {
42558     try {
42559       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42560     } catch (std::out_of_range& e) {
42561       {
42562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (std::exception& e) {
42565       {
42566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (Dali::DaliException e) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578
42579   jresult = (void *)result;
42580   return jresult;
42581 }
42582
42583
42584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42585   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42586   unsigned int arg2 ;
42587
42588   arg1 = (Dali::TapGestureDetector *)jarg1;
42589   arg2 = (unsigned int)jarg2;
42590   {
42591     try {
42592       (arg1)->SetMinimumTapsRequired(arg2);
42593     } catch (std::out_of_range& e) {
42594       {
42595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42596       };
42597     } catch (std::exception& e) {
42598       {
42599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42600       };
42601     } catch (Dali::DaliException e) {
42602       {
42603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42604       };
42605     } catch (...) {
42606       {
42607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42608       };
42609     }
42610   }
42611
42612 }
42613
42614
42615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42616   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42617   unsigned int arg2 ;
42618
42619   arg1 = (Dali::TapGestureDetector *)jarg1;
42620   arg2 = (unsigned int)jarg2;
42621   {
42622     try {
42623       (arg1)->SetMaximumTapsRequired(arg2);
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42631       };
42632     } catch (Dali::DaliException e) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42635       };
42636     } catch (...) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42639       };
42640     }
42641   }
42642
42643 }
42644
42645
42646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42647   unsigned int jresult ;
42648   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42649   unsigned int result;
42650
42651   arg1 = (Dali::TapGestureDetector *)jarg1;
42652   {
42653     try {
42654       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42655     } catch (std::out_of_range& e) {
42656       {
42657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42658       };
42659     } catch (std::exception& e) {
42660       {
42661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42662       };
42663     } catch (Dali::DaliException e) {
42664       {
42665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42666       };
42667     } catch (...) {
42668       {
42669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42670       };
42671     }
42672   }
42673
42674   jresult = result;
42675   return jresult;
42676 }
42677
42678
42679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42680   unsigned int jresult ;
42681   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42682   unsigned int result;
42683
42684   arg1 = (Dali::TapGestureDetector *)jarg1;
42685   {
42686     try {
42687       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42688     } catch (std::out_of_range& e) {
42689       {
42690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (std::exception& e) {
42693       {
42694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (Dali::DaliException e) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42699       };
42700     } catch (...) {
42701       {
42702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42703       };
42704     }
42705   }
42706
42707   jresult = result;
42708   return jresult;
42709 }
42710
42711
42712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42713   void * jresult ;
42714   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42715   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42716
42717   arg1 = (Dali::TapGestureDetector *)jarg1;
42718   {
42719     try {
42720       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42721     } catch (std::out_of_range& e) {
42722       {
42723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42724       };
42725     } catch (std::exception& e) {
42726       {
42727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42728       };
42729     } catch (Dali::DaliException e) {
42730       {
42731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42732       };
42733     } catch (...) {
42734       {
42735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42736       };
42737     }
42738   }
42739
42740   jresult = (void *)result;
42741   return jresult;
42742 }
42743
42744
42745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42746   void * jresult ;
42747   Dali::TapGesture *result = 0 ;
42748
42749   {
42750     try {
42751       result = (Dali::TapGesture *)new Dali::TapGesture();
42752     } catch (std::out_of_range& e) {
42753       {
42754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42755       };
42756     } catch (std::exception& e) {
42757       {
42758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42759       };
42760     } catch (Dali::DaliException e) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42763       };
42764     } catch (...) {
42765       {
42766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42767       };
42768     }
42769   }
42770
42771   jresult = (void *)result;
42772   return jresult;
42773 }
42774
42775
42776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42777   void * jresult ;
42778   Dali::TapGesture *arg1 = 0 ;
42779   Dali::TapGesture *result = 0 ;
42780
42781   arg1 = (Dali::TapGesture *)jarg1;
42782   if (!arg1) {
42783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42784     return 0;
42785   }
42786   {
42787     try {
42788       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42789     } catch (std::out_of_range& e) {
42790       {
42791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42792       };
42793     } catch (std::exception& e) {
42794       {
42795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (Dali::DaliException e) {
42798       {
42799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42800       };
42801     } catch (...) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42804       };
42805     }
42806   }
42807
42808   jresult = (void *)result;
42809   return jresult;
42810 }
42811
42812
42813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42814   void * jresult ;
42815   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42816   Dali::TapGesture *arg2 = 0 ;
42817   Dali::TapGesture *result = 0 ;
42818
42819   arg1 = (Dali::TapGesture *)jarg1;
42820   arg2 = (Dali::TapGesture *)jarg2;
42821   if (!arg2) {
42822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42823     return 0;
42824   }
42825   {
42826     try {
42827       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42828     } catch (std::out_of_range& e) {
42829       {
42830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42831       };
42832     } catch (std::exception& e) {
42833       {
42834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42835       };
42836     } catch (Dali::DaliException e) {
42837       {
42838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42839       };
42840     } catch (...) {
42841       {
42842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42843       };
42844     }
42845   }
42846
42847   jresult = (void *)result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42853   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42854
42855   arg1 = (Dali::TapGesture *)jarg1;
42856   {
42857     try {
42858       delete arg1;
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42866       };
42867     } catch (Dali::DaliException e) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42870       };
42871     } catch (...) {
42872       {
42873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42874       };
42875     }
42876   }
42877
42878 }
42879
42880
42881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42882   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42883   unsigned int arg2 ;
42884
42885   arg1 = (Dali::TapGesture *)jarg1;
42886   arg2 = (unsigned int)jarg2;
42887   if (arg1) (arg1)->numberOfTaps = arg2;
42888 }
42889
42890
42891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42892   unsigned int jresult ;
42893   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42894   unsigned int result;
42895
42896   arg1 = (Dali::TapGesture *)jarg1;
42897   result = (unsigned int) ((arg1)->numberOfTaps);
42898   jresult = result;
42899   return jresult;
42900 }
42901
42902
42903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42904   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42905   unsigned int arg2 ;
42906
42907   arg1 = (Dali::TapGesture *)jarg1;
42908   arg2 = (unsigned int)jarg2;
42909   if (arg1) (arg1)->numberOfTouches = arg2;
42910 }
42911
42912
42913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42914   unsigned int jresult ;
42915   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42916   unsigned int result;
42917
42918   arg1 = (Dali::TapGesture *)jarg1;
42919   result = (unsigned int) ((arg1)->numberOfTouches);
42920   jresult = result;
42921   return jresult;
42922 }
42923
42924
42925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42926   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42927   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42928
42929   arg1 = (Dali::TapGesture *)jarg1;
42930   arg2 = (Dali::Vector2 *)jarg2;
42931   if (arg1) (arg1)->screenPoint = *arg2;
42932 }
42933
42934
42935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42936   void * jresult ;
42937   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42938   Dali::Vector2 *result = 0 ;
42939
42940   arg1 = (Dali::TapGesture *)jarg1;
42941   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42942   jresult = (void *)result;
42943   return jresult;
42944 }
42945
42946
42947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42948   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42949   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42950
42951   arg1 = (Dali::TapGesture *)jarg1;
42952   arg2 = (Dali::Vector2 *)jarg2;
42953   if (arg1) (arg1)->localPoint = *arg2;
42954 }
42955
42956
42957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42958   void * jresult ;
42959   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42960   Dali::Vector2 *result = 0 ;
42961
42962   arg1 = (Dali::TapGesture *)jarg1;
42963   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42964   jresult = (void *)result;
42965   return jresult;
42966 }
42967
42968
42969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42970   void * jresult ;
42971   Dali::AlphaFunction *result = 0 ;
42972
42973   {
42974     try {
42975       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42976     } catch (std::out_of_range& e) {
42977       {
42978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42979       };
42980     } catch (std::exception& e) {
42981       {
42982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42983       };
42984     } catch (Dali::DaliException e) {
42985       {
42986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42987       };
42988     } catch (...) {
42989       {
42990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42991       };
42992     }
42993   }
42994
42995   jresult = (void *)result;
42996   return jresult;
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
43001   void * jresult ;
43002   Dali::AlphaFunction::BuiltinFunction arg1 ;
43003   Dali::AlphaFunction *result = 0 ;
43004
43005   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43006   {
43007     try {
43008       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43009     } catch (std::out_of_range& e) {
43010       {
43011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (std::exception& e) {
43014       {
43015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43016       };
43017     } catch (Dali::DaliException e) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43020       };
43021     } catch (...) {
43022       {
43023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43024       };
43025     }
43026   }
43027
43028   jresult = (void *)result;
43029   return jresult;
43030 }
43031
43032
43033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43034   void * jresult ;
43035   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43036   Dali::AlphaFunction *result = 0 ;
43037
43038   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43039   {
43040     try {
43041       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43042     } catch (std::out_of_range& e) {
43043       {
43044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43045       };
43046     } catch (std::exception& e) {
43047       {
43048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43049       };
43050     } catch (Dali::DaliException e) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43053       };
43054     } catch (...) {
43055       {
43056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43057       };
43058     }
43059   }
43060
43061   jresult = (void *)result;
43062   return jresult;
43063 }
43064
43065
43066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43067   void * jresult ;
43068   Dali::Vector2 *arg1 = 0 ;
43069   Dali::Vector2 *arg2 = 0 ;
43070   Dali::AlphaFunction *result = 0 ;
43071
43072   arg1 = (Dali::Vector2 *)jarg1;
43073   if (!arg1) {
43074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43075     return 0;
43076   }
43077   arg2 = (Dali::Vector2 *)jarg2;
43078   if (!arg2) {
43079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43080     return 0;
43081   }
43082   {
43083     try {
43084       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43085     } catch (std::out_of_range& e) {
43086       {
43087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43088       };
43089     } catch (std::exception& e) {
43090       {
43091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (Dali::DaliException e) {
43094       {
43095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43096       };
43097     } catch (...) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43100       };
43101     }
43102   }
43103
43104   jresult = (void *)result;
43105   return jresult;
43106 }
43107
43108
43109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43110   void * jresult ;
43111   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43112   Dali::Vector4 result;
43113
43114   arg1 = (Dali::AlphaFunction *)jarg1;
43115   {
43116     try {
43117       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43118     } catch (std::out_of_range& e) {
43119       {
43120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43121       };
43122     } catch (std::exception& e) {
43123       {
43124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43125       };
43126     } catch (Dali::DaliException e) {
43127       {
43128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43129       };
43130     } catch (...) {
43131       {
43132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43133       };
43134     }
43135   }
43136
43137   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43138   return jresult;
43139 }
43140
43141
43142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43143   void * jresult ;
43144   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43145   Dali::AlphaFunctionPrototype result;
43146
43147   arg1 = (Dali::AlphaFunction *)jarg1;
43148   {
43149     try {
43150       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (Dali::DaliException e) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43166       };
43167     }
43168   }
43169
43170   jresult = (void *)result;
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43176   int jresult ;
43177   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43178   Dali::AlphaFunction::BuiltinFunction result;
43179
43180   arg1 = (Dali::AlphaFunction *)jarg1;
43181   {
43182     try {
43183       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43184     } catch (std::out_of_range& e) {
43185       {
43186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (std::exception& e) {
43189       {
43190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43191       };
43192     } catch (Dali::DaliException e) {
43193       {
43194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43195       };
43196     } catch (...) {
43197       {
43198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43199       };
43200     }
43201   }
43202
43203   jresult = (int)result;
43204   return jresult;
43205 }
43206
43207
43208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43209   int jresult ;
43210   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43211   Dali::AlphaFunction::Mode result;
43212
43213   arg1 = (Dali::AlphaFunction *)jarg1;
43214   {
43215     try {
43216       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (Dali::DaliException e) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43228       };
43229     } catch (...) {
43230       {
43231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43232       };
43233     }
43234   }
43235
43236   jresult = (int)result;
43237   return jresult;
43238 }
43239
43240
43241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43242   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43243
43244   arg1 = (Dali::AlphaFunction *)jarg1;
43245   {
43246     try {
43247       delete arg1;
43248     } catch (std::out_of_range& e) {
43249       {
43250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43251       };
43252     } catch (std::exception& e) {
43253       {
43254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43255       };
43256     } catch (Dali::DaliException e) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43259       };
43260     } catch (...) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43263       };
43264     }
43265   }
43266
43267 }
43268
43269
43270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43271   void * jresult ;
43272   Dali::KeyFrames result;
43273
43274   {
43275     try {
43276       result = Dali::KeyFrames::New();
43277     } catch (std::out_of_range& e) {
43278       {
43279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43280       };
43281     } catch (std::exception& e) {
43282       {
43283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43284       };
43285     } catch (Dali::DaliException e) {
43286       {
43287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43288       };
43289     } catch (...) {
43290       {
43291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43292       };
43293     }
43294   }
43295
43296   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43297   return jresult;
43298 }
43299
43300
43301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43302   void * jresult ;
43303   Dali::BaseHandle arg1 ;
43304   Dali::BaseHandle *argp1 ;
43305   Dali::KeyFrames result;
43306
43307   argp1 = (Dali::BaseHandle *)jarg1;
43308   if (!argp1) {
43309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43310     return 0;
43311   }
43312   arg1 = *argp1;
43313   {
43314     try {
43315       result = Dali::KeyFrames::DownCast(arg1);
43316     } catch (std::out_of_range& e) {
43317       {
43318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43319       };
43320     } catch (std::exception& e) {
43321       {
43322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (Dali::DaliException e) {
43325       {
43326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43327       };
43328     } catch (...) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43331       };
43332     }
43333   }
43334
43335   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43341   void * jresult ;
43342   Dali::KeyFrames *result = 0 ;
43343
43344   {
43345     try {
43346       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43347     } catch (std::out_of_range& e) {
43348       {
43349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43350       };
43351     } catch (std::exception& e) {
43352       {
43353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (Dali::DaliException e) {
43356       {
43357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365
43366   jresult = (void *)result;
43367   return jresult;
43368 }
43369
43370
43371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43372   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43373
43374   arg1 = (Dali::KeyFrames *)jarg1;
43375   {
43376     try {
43377       delete arg1;
43378     } catch (std::out_of_range& e) {
43379       {
43380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43381       };
43382     } catch (std::exception& e) {
43383       {
43384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43385       };
43386     } catch (Dali::DaliException e) {
43387       {
43388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43389       };
43390     } catch (...) {
43391       {
43392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43393       };
43394     }
43395   }
43396
43397 }
43398
43399
43400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43401   void * jresult ;
43402   Dali::KeyFrames *arg1 = 0 ;
43403   Dali::KeyFrames *result = 0 ;
43404
43405   arg1 = (Dali::KeyFrames *)jarg1;
43406   if (!arg1) {
43407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43408     return 0;
43409   }
43410   {
43411     try {
43412       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43413     } catch (std::out_of_range& e) {
43414       {
43415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (std::exception& e) {
43418       {
43419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43420       };
43421     } catch (Dali::DaliException e) {
43422       {
43423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43424       };
43425     } catch (...) {
43426       {
43427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43428       };
43429     }
43430   }
43431
43432   jresult = (void *)result;
43433   return jresult;
43434 }
43435
43436
43437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43438   void * jresult ;
43439   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43440   Dali::KeyFrames *arg2 = 0 ;
43441   Dali::KeyFrames *result = 0 ;
43442
43443   arg1 = (Dali::KeyFrames *)jarg1;
43444   arg2 = (Dali::KeyFrames *)jarg2;
43445   if (!arg2) {
43446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43447     return 0;
43448   }
43449   {
43450     try {
43451       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43452     } catch (std::out_of_range& e) {
43453       {
43454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (std::exception& e) {
43457       {
43458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43459       };
43460     } catch (Dali::DaliException e) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43463       };
43464     } catch (...) {
43465       {
43466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43467       };
43468     }
43469   }
43470
43471   jresult = (void *)result;
43472   return jresult;
43473 }
43474
43475
43476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43477   int jresult ;
43478   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43479   Dali::Property::Type result;
43480
43481   arg1 = (Dali::KeyFrames *)jarg1;
43482   {
43483     try {
43484       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43485     } catch (std::out_of_range& e) {
43486       {
43487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43488       };
43489     } catch (std::exception& e) {
43490       {
43491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43492       };
43493     } catch (Dali::DaliException e) {
43494       {
43495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43496       };
43497     } catch (...) {
43498       {
43499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43500       };
43501     }
43502   }
43503
43504   jresult = (int)result;
43505   return jresult;
43506 }
43507
43508
43509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43510   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43511   float arg2 ;
43512   Dali::Property::Value arg3 ;
43513   Dali::Property::Value *argp3 ;
43514
43515   arg1 = (Dali::KeyFrames *)jarg1;
43516   arg2 = (float)jarg2;
43517   argp3 = (Dali::Property::Value *)jarg3;
43518   if (!argp3) {
43519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43520     return ;
43521   }
43522   arg3 = *argp3;
43523   {
43524     try {
43525       (arg1)->Add(arg2,arg3);
43526     } catch (std::out_of_range& e) {
43527       {
43528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43529       };
43530     } catch (std::exception& e) {
43531       {
43532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43533       };
43534     } catch (Dali::DaliException e) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43537       };
43538     } catch (...) {
43539       {
43540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43541       };
43542     }
43543   }
43544
43545 }
43546
43547
43548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43549   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43550   float arg2 ;
43551   Dali::Property::Value arg3 ;
43552   Dali::AlphaFunction arg4 ;
43553   Dali::Property::Value *argp3 ;
43554   Dali::AlphaFunction *argp4 ;
43555
43556   arg1 = (Dali::KeyFrames *)jarg1;
43557   arg2 = (float)jarg2;
43558   argp3 = (Dali::Property::Value *)jarg3;
43559   if (!argp3) {
43560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43561     return ;
43562   }
43563   arg3 = *argp3;
43564   argp4 = (Dali::AlphaFunction *)jarg4;
43565   if (!argp4) {
43566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43567     return ;
43568   }
43569   arg4 = *argp4;
43570   {
43571     try {
43572       (arg1)->Add(arg2,arg3,arg4);
43573     } catch (std::out_of_range& e) {
43574       {
43575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43576       };
43577     } catch (std::exception& e) {
43578       {
43579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43580       };
43581     } catch (Dali::DaliException e) {
43582       {
43583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43584       };
43585     } catch (...) {
43586       {
43587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43588       };
43589     }
43590   }
43591
43592 }
43593
43594
43595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43596   int jresult ;
43597   int result;
43598
43599   result = (int)Dali::Path::Property::POINTS;
43600   jresult = (int)result;
43601   return jresult;
43602 }
43603
43604
43605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43606   int jresult ;
43607   int result;
43608
43609   result = (int)Dali::Path::Property::CONTROL_POINTS;
43610   jresult = (int)result;
43611   return jresult;
43612 }
43613
43614
43615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43616   void * jresult ;
43617   Dali::Path::Property *result = 0 ;
43618
43619   {
43620     try {
43621       result = (Dali::Path::Property *)new Dali::Path::Property();
43622     } catch (std::out_of_range& e) {
43623       {
43624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43625       };
43626     } catch (std::exception& e) {
43627       {
43628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43629       };
43630     } catch (Dali::DaliException e) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43633       };
43634     } catch (...) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43637       };
43638     }
43639   }
43640
43641   jresult = (void *)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43647   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43648
43649   arg1 = (Dali::Path::Property *)jarg1;
43650   {
43651     try {
43652       delete arg1;
43653     } catch (std::out_of_range& e) {
43654       {
43655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43656       };
43657     } catch (std::exception& e) {
43658       {
43659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43660       };
43661     } catch (Dali::DaliException e) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43664       };
43665     } catch (...) {
43666       {
43667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43668       };
43669     }
43670   }
43671
43672 }
43673
43674
43675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43676   void * jresult ;
43677   Dali::Path result;
43678
43679   {
43680     try {
43681       result = Dali::Path::New();
43682     } catch (std::out_of_range& e) {
43683       {
43684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43685       };
43686     } catch (std::exception& e) {
43687       {
43688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (Dali::DaliException e) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43697       };
43698     }
43699   }
43700
43701   jresult = new Dali::Path((const Dali::Path &)result);
43702   return jresult;
43703 }
43704
43705
43706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43707   void * jresult ;
43708   Dali::BaseHandle arg1 ;
43709   Dali::BaseHandle *argp1 ;
43710   Dali::Path result;
43711
43712   argp1 = (Dali::BaseHandle *)jarg1;
43713   if (!argp1) {
43714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43715     return 0;
43716   }
43717   arg1 = *argp1;
43718   {
43719     try {
43720       result = Dali::Path::DownCast(arg1);
43721     } catch (std::out_of_range& e) {
43722       {
43723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (std::exception& e) {
43726       {
43727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (Dali::DaliException e) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43732       };
43733     } catch (...) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43736       };
43737     }
43738   }
43739
43740   jresult = new Dali::Path((const Dali::Path &)result);
43741   return jresult;
43742 }
43743
43744
43745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43746   void * jresult ;
43747   Dali::Path *result = 0 ;
43748
43749   {
43750     try {
43751       result = (Dali::Path *)new Dali::Path();
43752     } catch (std::out_of_range& e) {
43753       {
43754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43755       };
43756     } catch (std::exception& e) {
43757       {
43758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43759       };
43760     } catch (Dali::DaliException e) {
43761       {
43762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43763       };
43764     } catch (...) {
43765       {
43766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43767       };
43768     }
43769   }
43770
43771   jresult = (void *)result;
43772   return jresult;
43773 }
43774
43775
43776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43777   Dali::Path *arg1 = (Dali::Path *) 0 ;
43778
43779   arg1 = (Dali::Path *)jarg1;
43780   {
43781     try {
43782       delete arg1;
43783     } catch (std::out_of_range& e) {
43784       {
43785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43786       };
43787     } catch (std::exception& e) {
43788       {
43789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43790       };
43791     } catch (Dali::DaliException e) {
43792       {
43793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43794       };
43795     } catch (...) {
43796       {
43797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43798       };
43799     }
43800   }
43801
43802 }
43803
43804
43805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43806   void * jresult ;
43807   Dali::Path *arg1 = 0 ;
43808   Dali::Path *result = 0 ;
43809
43810   arg1 = (Dali::Path *)jarg1;
43811   if (!arg1) {
43812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43813     return 0;
43814   }
43815   {
43816     try {
43817       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43818     } catch (std::out_of_range& e) {
43819       {
43820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43821       };
43822     } catch (std::exception& e) {
43823       {
43824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43825       };
43826     } catch (Dali::DaliException e) {
43827       {
43828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43829       };
43830     } catch (...) {
43831       {
43832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43833       };
43834     }
43835   }
43836
43837   jresult = (void *)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43843   void * jresult ;
43844   Dali::Path *arg1 = (Dali::Path *) 0 ;
43845   Dali::Path *arg2 = 0 ;
43846   Dali::Path *result = 0 ;
43847
43848   arg1 = (Dali::Path *)jarg1;
43849   arg2 = (Dali::Path *)jarg2;
43850   if (!arg2) {
43851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43852     return 0;
43853   }
43854   {
43855     try {
43856       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43857     } catch (std::out_of_range& e) {
43858       {
43859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43860       };
43861     } catch (std::exception& e) {
43862       {
43863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43864       };
43865     } catch (Dali::DaliException e) {
43866       {
43867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43872       };
43873     }
43874   }
43875
43876   jresult = (void *)result;
43877   return jresult;
43878 }
43879
43880
43881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43882   Dali::Path *arg1 = (Dali::Path *) 0 ;
43883   Dali::Vector3 *arg2 = 0 ;
43884
43885   arg1 = (Dali::Path *)jarg1;
43886   arg2 = (Dali::Vector3 *)jarg2;
43887   if (!arg2) {
43888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43889     return ;
43890   }
43891   {
43892     try {
43893       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43894     } catch (std::out_of_range& e) {
43895       {
43896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43897       };
43898     } catch (std::exception& e) {
43899       {
43900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43901       };
43902     } catch (Dali::DaliException e) {
43903       {
43904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43905       };
43906     } catch (...) {
43907       {
43908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43909       };
43910     }
43911   }
43912
43913 }
43914
43915
43916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43917   Dali::Path *arg1 = (Dali::Path *) 0 ;
43918   Dali::Vector3 *arg2 = 0 ;
43919
43920   arg1 = (Dali::Path *)jarg1;
43921   arg2 = (Dali::Vector3 *)jarg2;
43922   if (!arg2) {
43923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43924     return ;
43925   }
43926   {
43927     try {
43928       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43929     } catch (std::out_of_range& e) {
43930       {
43931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43932       };
43933     } catch (std::exception& e) {
43934       {
43935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43936       };
43937     } catch (Dali::DaliException e) {
43938       {
43939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43940       };
43941     } catch (...) {
43942       {
43943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43944       };
43945     }
43946   }
43947
43948 }
43949
43950
43951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43952   Dali::Path *arg1 = (Dali::Path *) 0 ;
43953   float arg2 ;
43954
43955   arg1 = (Dali::Path *)jarg1;
43956   arg2 = (float)jarg2;
43957   {
43958     try {
43959       (arg1)->GenerateControlPoints(arg2);
43960     } catch (std::out_of_range& e) {
43961       {
43962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43963       };
43964     } catch (std::exception& e) {
43965       {
43966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43967       };
43968     } catch (Dali::DaliException e) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43971       };
43972     } catch (...) {
43973       {
43974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43975       };
43976     }
43977   }
43978
43979 }
43980
43981
43982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43983   Dali::Path *arg1 = (Dali::Path *) 0 ;
43984   float arg2 ;
43985   Dali::Vector3 *arg3 = 0 ;
43986   Dali::Vector3 *arg4 = 0 ;
43987
43988   arg1 = (Dali::Path *)jarg1;
43989   arg2 = (float)jarg2;
43990   arg3 = (Dali::Vector3 *)jarg3;
43991   if (!arg3) {
43992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43993     return ;
43994   }
43995   arg4 = (Dali::Vector3 *)jarg4;
43996   if (!arg4) {
43997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43998     return ;
43999   }
44000   {
44001     try {
44002       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44018       };
44019     }
44020   }
44021
44022 }
44023
44024
44025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44026   void * jresult ;
44027   Dali::Path *arg1 = (Dali::Path *) 0 ;
44028   size_t arg2 ;
44029   Dali::Vector3 *result = 0 ;
44030
44031   arg1 = (Dali::Path *)jarg1;
44032   arg2 = (size_t)jarg2;
44033   {
44034     try {
44035       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44036     } catch (std::out_of_range& e) {
44037       {
44038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44039       };
44040     } catch (std::exception& e) {
44041       {
44042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44043       };
44044     } catch (Dali::DaliException e) {
44045       {
44046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44047       };
44048     } catch (...) {
44049       {
44050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44051       };
44052     }
44053   }
44054
44055   jresult = (void *)result;
44056   return jresult;
44057 }
44058
44059
44060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44061   void * jresult ;
44062   Dali::Path *arg1 = (Dali::Path *) 0 ;
44063   size_t arg2 ;
44064   Dali::Vector3 *result = 0 ;
44065
44066   arg1 = (Dali::Path *)jarg1;
44067   arg2 = (size_t)jarg2;
44068   {
44069     try {
44070       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44071     } catch (std::out_of_range& e) {
44072       {
44073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44074       };
44075     } catch (std::exception& e) {
44076       {
44077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44078       };
44079     } catch (Dali::DaliException e) {
44080       {
44081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44082       };
44083     } catch (...) {
44084       {
44085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44086       };
44087     }
44088   }
44089
44090   jresult = (void *)result;
44091   return jresult;
44092 }
44093
44094
44095 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44096   unsigned long jresult ;
44097   Dali::Path *arg1 = (Dali::Path *) 0 ;
44098   size_t result;
44099
44100   arg1 = (Dali::Path *)jarg1;
44101   {
44102     try {
44103       result = ((Dali::Path const *)arg1)->GetPointCount();
44104     } catch (std::out_of_range& e) {
44105       {
44106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44107       };
44108     } catch (std::exception& e) {
44109       {
44110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44111       };
44112     } catch (Dali::DaliException e) {
44113       {
44114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44115       };
44116     } catch (...) {
44117       {
44118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44119       };
44120     }
44121   }
44122
44123   jresult = (unsigned long)result;
44124   return jresult;
44125 }
44126
44127
44128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44129   void * jresult ;
44130   float arg1 ;
44131   Dali::TimePeriod *result = 0 ;
44132
44133   arg1 = (float)jarg1;
44134   {
44135     try {
44136       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44137     } catch (std::out_of_range& e) {
44138       {
44139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (std::exception& e) {
44142       {
44143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44144       };
44145     } catch (Dali::DaliException e) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44148       };
44149     } catch (...) {
44150       {
44151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44152       };
44153     }
44154   }
44155
44156   jresult = (void *)result;
44157   return jresult;
44158 }
44159
44160
44161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44162   void * jresult ;
44163   float arg1 ;
44164   float arg2 ;
44165   Dali::TimePeriod *result = 0 ;
44166
44167   arg1 = (float)jarg1;
44168   arg2 = (float)jarg2;
44169   {
44170     try {
44171       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44179       };
44180     } catch (Dali::DaliException e) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44183       };
44184     } catch (...) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44187       };
44188     }
44189   }
44190
44191   jresult = (void *)result;
44192   return jresult;
44193 }
44194
44195
44196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44197   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44198
44199   arg1 = (Dali::TimePeriod *)jarg1;
44200   {
44201     try {
44202       delete arg1;
44203     } catch (std::out_of_range& e) {
44204       {
44205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44206       };
44207     } catch (std::exception& e) {
44208       {
44209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (Dali::DaliException e) {
44212       {
44213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44214       };
44215     } catch (...) {
44216       {
44217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44218       };
44219     }
44220   }
44221
44222 }
44223
44224
44225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44226   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44227   float arg2 ;
44228
44229   arg1 = (Dali::TimePeriod *)jarg1;
44230   arg2 = (float)jarg2;
44231   if (arg1) (arg1)->delaySeconds = arg2;
44232 }
44233
44234
44235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44236   float jresult ;
44237   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44238   float result;
44239
44240   arg1 = (Dali::TimePeriod *)jarg1;
44241   result = (float) ((arg1)->delaySeconds);
44242   jresult = result;
44243   return jresult;
44244 }
44245
44246
44247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44248   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44249   float arg2 ;
44250
44251   arg1 = (Dali::TimePeriod *)jarg1;
44252   arg2 = (float)jarg2;
44253   if (arg1) (arg1)->durationSeconds = arg2;
44254 }
44255
44256
44257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44258   float jresult ;
44259   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44260   float result;
44261
44262   arg1 = (Dali::TimePeriod *)jarg1;
44263   result = (float) ((arg1)->durationSeconds);
44264   jresult = result;
44265   return jresult;
44266 }
44267
44268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44269   int jresult ;
44270   int result;
44271
44272   result = (int)Dali::LinearConstrainer::Property::VALUE;
44273   jresult = (int)result;
44274   return jresult;
44275 }
44276
44277
44278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44279   int jresult ;
44280   int result;
44281
44282   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44283   jresult = (int)result;
44284   return jresult;
44285 }
44286
44287
44288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44289   void * jresult ;
44290   Dali::LinearConstrainer::Property *result = 0 ;
44291
44292   {
44293     try {
44294       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44295     } catch (std::out_of_range& e) {
44296       {
44297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44298       };
44299     } catch (std::exception& e) {
44300       {
44301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44302       };
44303     } catch (Dali::DaliException e) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44306       };
44307     } catch (...) {
44308       {
44309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44310       };
44311     }
44312   }
44313
44314   jresult = (void *)result;
44315   return jresult;
44316 }
44317
44318
44319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44320   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44321
44322   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44323   {
44324     try {
44325       delete arg1;
44326     } catch (std::out_of_range& e) {
44327       {
44328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44329       };
44330     } catch (std::exception& e) {
44331       {
44332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44333       };
44334     } catch (Dali::DaliException e) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44337       };
44338     } catch (...) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44341       };
44342     }
44343   }
44344
44345 }
44346
44347
44348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44349   void * jresult ;
44350   Dali::LinearConstrainer result;
44351
44352   {
44353     try {
44354       result = Dali::LinearConstrainer::New();
44355     } catch (std::out_of_range& e) {
44356       {
44357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44358       };
44359     } catch (std::exception& e) {
44360       {
44361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44362       };
44363     } catch (Dali::DaliException e) {
44364       {
44365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44366       };
44367     } catch (...) {
44368       {
44369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44370       };
44371     }
44372   }
44373
44374   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44375   return jresult;
44376 }
44377
44378
44379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44380   void * jresult ;
44381   Dali::BaseHandle arg1 ;
44382   Dali::BaseHandle *argp1 ;
44383   Dali::LinearConstrainer result;
44384
44385   argp1 = (Dali::BaseHandle *)jarg1;
44386   if (!argp1) {
44387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44388     return 0;
44389   }
44390   arg1 = *argp1;
44391   {
44392     try {
44393       result = Dali::LinearConstrainer::DownCast(arg1);
44394     } catch (std::out_of_range& e) {
44395       {
44396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44397       };
44398     } catch (std::exception& e) {
44399       {
44400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44401       };
44402     } catch (Dali::DaliException e) {
44403       {
44404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44405       };
44406     } catch (...) {
44407       {
44408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44409       };
44410     }
44411   }
44412
44413   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44414   return jresult;
44415 }
44416
44417
44418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44419   void * jresult ;
44420   Dali::LinearConstrainer *result = 0 ;
44421
44422   {
44423     try {
44424       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44432       };
44433     } catch (Dali::DaliException e) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44436       };
44437     } catch (...) {
44438       {
44439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44440       };
44441     }
44442   }
44443
44444   jresult = (void *)result;
44445   return jresult;
44446 }
44447
44448
44449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44450   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44451
44452   arg1 = (Dali::LinearConstrainer *)jarg1;
44453   {
44454     try {
44455       delete arg1;
44456     } catch (std::out_of_range& e) {
44457       {
44458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44459       };
44460     } catch (std::exception& e) {
44461       {
44462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44463       };
44464     } catch (Dali::DaliException e) {
44465       {
44466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44467       };
44468     } catch (...) {
44469       {
44470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44471       };
44472     }
44473   }
44474
44475 }
44476
44477
44478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44479   void * jresult ;
44480   Dali::LinearConstrainer *arg1 = 0 ;
44481   Dali::LinearConstrainer *result = 0 ;
44482
44483   arg1 = (Dali::LinearConstrainer *)jarg1;
44484   if (!arg1) {
44485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44486     return 0;
44487   }
44488   {
44489     try {
44490       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44491     } catch (std::out_of_range& e) {
44492       {
44493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44494       };
44495     } catch (std::exception& e) {
44496       {
44497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44498       };
44499     } catch (Dali::DaliException e) {
44500       {
44501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44502       };
44503     } catch (...) {
44504       {
44505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44506       };
44507     }
44508   }
44509
44510   jresult = (void *)result;
44511   return jresult;
44512 }
44513
44514
44515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44516   void * jresult ;
44517   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44518   Dali::LinearConstrainer *arg2 = 0 ;
44519   Dali::LinearConstrainer *result = 0 ;
44520
44521   arg1 = (Dali::LinearConstrainer *)jarg1;
44522   arg2 = (Dali::LinearConstrainer *)jarg2;
44523   if (!arg2) {
44524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44525     return 0;
44526   }
44527   {
44528     try {
44529       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44530     } catch (std::out_of_range& e) {
44531       {
44532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44533       };
44534     } catch (std::exception& e) {
44535       {
44536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44537       };
44538     } catch (Dali::DaliException e) {
44539       {
44540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44541       };
44542     } catch (...) {
44543       {
44544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44545       };
44546     }
44547   }
44548
44549   jresult = (void *)result;
44550   return jresult;
44551 }
44552
44553
44554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44555   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44556   SwigValueWrapper< Dali::Property > arg2 ;
44557   SwigValueWrapper< Dali::Property > arg3 ;
44558   Dali::Vector2 *arg4 = 0 ;
44559   Dali::Vector2 *arg5 = 0 ;
44560   Dali::Property *argp2 ;
44561   Dali::Property *argp3 ;
44562
44563   arg1 = (Dali::LinearConstrainer *)jarg1;
44564   argp2 = (Dali::Property *)jarg2;
44565   if (!argp2) {
44566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44567     return ;
44568   }
44569   arg2 = *argp2;
44570   argp3 = (Dali::Property *)jarg3;
44571   if (!argp3) {
44572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44573     return ;
44574   }
44575   arg3 = *argp3;
44576   arg4 = (Dali::Vector2 *)jarg4;
44577   if (!arg4) {
44578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44579     return ;
44580   }
44581   arg5 = (Dali::Vector2 *)jarg5;
44582   if (!arg5) {
44583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44584     return ;
44585   }
44586   {
44587     try {
44588       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44589     } catch (std::out_of_range& e) {
44590       {
44591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (std::exception& e) {
44594       {
44595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44596       };
44597     } catch (Dali::DaliException e) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44600       };
44601     } catch (...) {
44602       {
44603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44604       };
44605     }
44606   }
44607
44608 }
44609
44610
44611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44612   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44613   SwigValueWrapper< Dali::Property > arg2 ;
44614   SwigValueWrapper< Dali::Property > arg3 ;
44615   Dali::Vector2 *arg4 = 0 ;
44616   Dali::Property *argp2 ;
44617   Dali::Property *argp3 ;
44618
44619   arg1 = (Dali::LinearConstrainer *)jarg1;
44620   argp2 = (Dali::Property *)jarg2;
44621   if (!argp2) {
44622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44623     return ;
44624   }
44625   arg2 = *argp2;
44626   argp3 = (Dali::Property *)jarg3;
44627   if (!argp3) {
44628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44629     return ;
44630   }
44631   arg3 = *argp3;
44632   arg4 = (Dali::Vector2 *)jarg4;
44633   if (!arg4) {
44634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44635     return ;
44636   }
44637   {
44638     try {
44639       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44640     } catch (std::out_of_range& e) {
44641       {
44642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44643       };
44644     } catch (std::exception& e) {
44645       {
44646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44647       };
44648     } catch (Dali::DaliException e) {
44649       {
44650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44651       };
44652     } catch (...) {
44653       {
44654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44655       };
44656     }
44657   }
44658
44659 }
44660
44661
44662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44663   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44664   Dali::Handle *arg2 = 0 ;
44665
44666   arg1 = (Dali::LinearConstrainer *)jarg1;
44667   arg2 = (Dali::Handle *)jarg2;
44668   if (!arg2) {
44669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44670     return ;
44671   }
44672   {
44673     try {
44674       (arg1)->Remove(*arg2);
44675     } catch (std::out_of_range& e) {
44676       {
44677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44678       };
44679     } catch (std::exception& e) {
44680       {
44681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44682       };
44683     } catch (Dali::DaliException e) {
44684       {
44685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44686       };
44687     } catch (...) {
44688       {
44689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44690       };
44691     }
44692   }
44693
44694 }
44695
44696
44697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44698   int jresult ;
44699   int result;
44700
44701   result = (int)Dali::PathConstrainer::Property::FORWARD;
44702   jresult = (int)result;
44703   return jresult;
44704 }
44705
44706
44707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44708   int jresult ;
44709   int result;
44710
44711   result = (int)Dali::PathConstrainer::Property::POINTS;
44712   jresult = (int)result;
44713   return jresult;
44714 }
44715
44716
44717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44718   int jresult ;
44719   int result;
44720
44721   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44722   jresult = (int)result;
44723   return jresult;
44724 }
44725
44726
44727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44728   void * jresult ;
44729   Dali::PathConstrainer::Property *result = 0 ;
44730
44731   {
44732     try {
44733       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44734     } catch (std::out_of_range& e) {
44735       {
44736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44737       };
44738     } catch (std::exception& e) {
44739       {
44740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44741       };
44742     } catch (Dali::DaliException e) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44745       };
44746     } catch (...) {
44747       {
44748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44749       };
44750     }
44751   }
44752
44753   jresult = (void *)result;
44754   return jresult;
44755 }
44756
44757
44758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44759   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44760
44761   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44762   {
44763     try {
44764       delete arg1;
44765     } catch (std::out_of_range& e) {
44766       {
44767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44768       };
44769     } catch (std::exception& e) {
44770       {
44771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44772       };
44773     } catch (Dali::DaliException e) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44780       };
44781     }
44782   }
44783
44784 }
44785
44786
44787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44788   void * jresult ;
44789   Dali::PathConstrainer result;
44790
44791   {
44792     try {
44793       result = Dali::PathConstrainer::New();
44794     } catch (std::out_of_range& e) {
44795       {
44796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44797       };
44798     } catch (std::exception& e) {
44799       {
44800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44801       };
44802     } catch (Dali::DaliException e) {
44803       {
44804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44805       };
44806     } catch (...) {
44807       {
44808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44809       };
44810     }
44811   }
44812
44813   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44819   void * jresult ;
44820   Dali::BaseHandle arg1 ;
44821   Dali::BaseHandle *argp1 ;
44822   Dali::PathConstrainer result;
44823
44824   argp1 = (Dali::BaseHandle *)jarg1;
44825   if (!argp1) {
44826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44827     return 0;
44828   }
44829   arg1 = *argp1;
44830   {
44831     try {
44832       result = Dali::PathConstrainer::DownCast(arg1);
44833     } catch (std::out_of_range& e) {
44834       {
44835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44836       };
44837     } catch (std::exception& e) {
44838       {
44839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44840       };
44841     } catch (Dali::DaliException e) {
44842       {
44843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44844       };
44845     } catch (...) {
44846       {
44847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44848       };
44849     }
44850   }
44851
44852   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44853   return jresult;
44854 }
44855
44856
44857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44858   void * jresult ;
44859   Dali::PathConstrainer *result = 0 ;
44860
44861   {
44862     try {
44863       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44864     } catch (std::out_of_range& e) {
44865       {
44866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44867       };
44868     } catch (std::exception& e) {
44869       {
44870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44871       };
44872     } catch (Dali::DaliException e) {
44873       {
44874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44875       };
44876     } catch (...) {
44877       {
44878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44879       };
44880     }
44881   }
44882
44883   jresult = (void *)result;
44884   return jresult;
44885 }
44886
44887
44888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44889   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44890
44891   arg1 = (Dali::PathConstrainer *)jarg1;
44892   {
44893     try {
44894       delete arg1;
44895     } catch (std::out_of_range& e) {
44896       {
44897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44898       };
44899     } catch (std::exception& e) {
44900       {
44901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44902       };
44903     } catch (Dali::DaliException e) {
44904       {
44905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44906       };
44907     } catch (...) {
44908       {
44909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44910       };
44911     }
44912   }
44913
44914 }
44915
44916
44917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44918   void * jresult ;
44919   Dali::PathConstrainer *arg1 = 0 ;
44920   Dali::PathConstrainer *result = 0 ;
44921
44922   arg1 = (Dali::PathConstrainer *)jarg1;
44923   if (!arg1) {
44924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44925     return 0;
44926   }
44927   {
44928     try {
44929       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44930     } catch (std::out_of_range& e) {
44931       {
44932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44933       };
44934     } catch (std::exception& e) {
44935       {
44936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (Dali::DaliException e) {
44939       {
44940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44941       };
44942     } catch (...) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44945       };
44946     }
44947   }
44948
44949   jresult = (void *)result;
44950   return jresult;
44951 }
44952
44953
44954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44955   void * jresult ;
44956   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44957   Dali::PathConstrainer *arg2 = 0 ;
44958   Dali::PathConstrainer *result = 0 ;
44959
44960   arg1 = (Dali::PathConstrainer *)jarg1;
44961   arg2 = (Dali::PathConstrainer *)jarg2;
44962   if (!arg2) {
44963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44964     return 0;
44965   }
44966   {
44967     try {
44968       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44969     } catch (std::out_of_range& e) {
44970       {
44971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44972       };
44973     } catch (std::exception& e) {
44974       {
44975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44976       };
44977     } catch (Dali::DaliException e) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44980       };
44981     } catch (...) {
44982       {
44983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44984       };
44985     }
44986   }
44987
44988   jresult = (void *)result;
44989   return jresult;
44990 }
44991
44992
44993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44994   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44995   SwigValueWrapper< Dali::Property > arg2 ;
44996   SwigValueWrapper< Dali::Property > arg3 ;
44997   Dali::Vector2 *arg4 = 0 ;
44998   Dali::Vector2 *arg5 = 0 ;
44999   Dali::Property *argp2 ;
45000   Dali::Property *argp3 ;
45001
45002   arg1 = (Dali::PathConstrainer *)jarg1;
45003   argp2 = (Dali::Property *)jarg2;
45004   if (!argp2) {
45005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45006     return ;
45007   }
45008   arg2 = *argp2;
45009   argp3 = (Dali::Property *)jarg3;
45010   if (!argp3) {
45011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45012     return ;
45013   }
45014   arg3 = *argp3;
45015   arg4 = (Dali::Vector2 *)jarg4;
45016   if (!arg4) {
45017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45018     return ;
45019   }
45020   arg5 = (Dali::Vector2 *)jarg5;
45021   if (!arg5) {
45022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45023     return ;
45024   }
45025   {
45026     try {
45027       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45028     } catch (std::out_of_range& e) {
45029       {
45030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45031       };
45032     } catch (std::exception& e) {
45033       {
45034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45035       };
45036     } catch (Dali::DaliException e) {
45037       {
45038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45039       };
45040     } catch (...) {
45041       {
45042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45043       };
45044     }
45045   }
45046
45047 }
45048
45049
45050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45051   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45052   SwigValueWrapper< Dali::Property > arg2 ;
45053   SwigValueWrapper< Dali::Property > arg3 ;
45054   Dali::Vector2 *arg4 = 0 ;
45055   Dali::Property *argp2 ;
45056   Dali::Property *argp3 ;
45057
45058   arg1 = (Dali::PathConstrainer *)jarg1;
45059   argp2 = (Dali::Property *)jarg2;
45060   if (!argp2) {
45061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45062     return ;
45063   }
45064   arg2 = *argp2;
45065   argp3 = (Dali::Property *)jarg3;
45066   if (!argp3) {
45067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45068     return ;
45069   }
45070   arg3 = *argp3;
45071   arg4 = (Dali::Vector2 *)jarg4;
45072   if (!arg4) {
45073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45074     return ;
45075   }
45076   {
45077     try {
45078       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45079     } catch (std::out_of_range& e) {
45080       {
45081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45082       };
45083     } catch (std::exception& e) {
45084       {
45085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45086       };
45087     } catch (Dali::DaliException e) {
45088       {
45089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45090       };
45091     } catch (...) {
45092       {
45093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45094       };
45095     }
45096   }
45097
45098 }
45099
45100
45101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45102   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45103   Dali::Handle *arg2 = 0 ;
45104
45105   arg1 = (Dali::PathConstrainer *)jarg1;
45106   arg2 = (Dali::Handle *)jarg2;
45107   if (!arg2) {
45108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45109     return ;
45110   }
45111   {
45112     try {
45113       (arg1)->Remove(*arg2);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45129       };
45130     }
45131   }
45132
45133 }
45134
45135
45136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45137   int jresult ;
45138   Dali::FittingMode::Type result;
45139
45140   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45141   jresult = (int)result;
45142   return jresult;
45143 }
45144
45145
45146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45147   int jresult ;
45148   Dali::SamplingMode::Type result;
45149
45150   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45151   jresult = (int)result;
45152   return jresult;
45153 }
45154
45155
45156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45157   void * jresult ;
45158   Dali::BufferImage *result = 0 ;
45159
45160   {
45161     try {
45162       result = (Dali::BufferImage *)new Dali::BufferImage();
45163     } catch (std::out_of_range& e) {
45164       {
45165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45166       };
45167     } catch (std::exception& e) {
45168       {
45169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45170       };
45171     } catch (Dali::DaliException e) {
45172       {
45173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45174       };
45175     } catch (...) {
45176       {
45177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45178       };
45179     }
45180   }
45181
45182   jresult = (void *)result;
45183   return jresult;
45184 }
45185
45186
45187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45188   void * jresult ;
45189   unsigned int arg1 ;
45190   unsigned int arg2 ;
45191   Dali::Pixel::Format arg3 ;
45192   Dali::BufferImage result;
45193
45194   arg1 = (unsigned int)jarg1;
45195   arg2 = (unsigned int)jarg2;
45196   arg3 = (Dali::Pixel::Format)jarg3;
45197   {
45198     try {
45199       result = Dali::BufferImage::New(arg1,arg2,arg3);
45200     } catch (std::out_of_range& e) {
45201       {
45202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45203       };
45204     } catch (std::exception& e) {
45205       {
45206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45207       };
45208     } catch (Dali::DaliException e) {
45209       {
45210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45211       };
45212     } catch (...) {
45213       {
45214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45215       };
45216     }
45217   }
45218
45219   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45220   return jresult;
45221 }
45222
45223
45224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45225   void * jresult ;
45226   unsigned int arg1 ;
45227   unsigned int arg2 ;
45228   Dali::BufferImage result;
45229
45230   arg1 = (unsigned int)jarg1;
45231   arg2 = (unsigned int)jarg2;
45232   {
45233     try {
45234       result = Dali::BufferImage::New(arg1,arg2);
45235     } catch (std::out_of_range& e) {
45236       {
45237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (std::exception& e) {
45240       {
45241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (Dali::DaliException e) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253
45254   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45260   void * jresult ;
45261   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45262   unsigned int arg2 ;
45263   unsigned int arg3 ;
45264   Dali::Pixel::Format arg4 ;
45265   unsigned int arg5 ;
45266   Dali::BufferImage result;
45267
45268   arg1 = jarg1;
45269   arg2 = (unsigned int)jarg2;
45270   arg3 = (unsigned int)jarg3;
45271   arg4 = (Dali::Pixel::Format)jarg4;
45272   arg5 = (unsigned int)jarg5;
45273   {
45274     try {
45275       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45276     } catch (std::out_of_range& e) {
45277       {
45278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45279       };
45280     } catch (std::exception& e) {
45281       {
45282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45283       };
45284     } catch (Dali::DaliException e) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45287       };
45288     } catch (...) {
45289       {
45290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45291       };
45292     }
45293   }
45294
45295   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45296
45297
45298   return jresult;
45299 }
45300
45301
45302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45303   void * jresult ;
45304   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45305   unsigned int arg2 ;
45306   unsigned int arg3 ;
45307   Dali::Pixel::Format arg4 ;
45308   Dali::BufferImage result;
45309
45310   arg1 = jarg1;
45311   arg2 = (unsigned int)jarg2;
45312   arg3 = (unsigned int)jarg3;
45313   arg4 = (Dali::Pixel::Format)jarg4;
45314   {
45315     try {
45316       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45317     } catch (std::out_of_range& e) {
45318       {
45319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45320       };
45321     } catch (std::exception& e) {
45322       {
45323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45324       };
45325     } catch (Dali::DaliException e) {
45326       {
45327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45328       };
45329     } catch (...) {
45330       {
45331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45332       };
45333     }
45334   }
45335
45336   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45337
45338
45339   return jresult;
45340 }
45341
45342
45343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45344   void * jresult ;
45345   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45346   unsigned int arg2 ;
45347   unsigned int arg3 ;
45348   Dali::BufferImage result;
45349
45350   arg1 = jarg1;
45351   arg2 = (unsigned int)jarg2;
45352   arg3 = (unsigned int)jarg3;
45353   {
45354     try {
45355       result = Dali::BufferImage::New(arg1,arg2,arg3);
45356     } catch (std::out_of_range& e) {
45357       {
45358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45359       };
45360     } catch (std::exception& e) {
45361       {
45362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45363       };
45364     } catch (Dali::DaliException e) {
45365       {
45366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45367       };
45368     } catch (...) {
45369       {
45370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45371       };
45372     }
45373   }
45374
45375   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45376
45377
45378   return jresult;
45379 }
45380
45381
45382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45383   void * jresult ;
45384   Dali::BaseHandle arg1 ;
45385   Dali::BaseHandle *argp1 ;
45386   Dali::BufferImage result;
45387
45388   argp1 = (Dali::BaseHandle *)jarg1;
45389   if (!argp1) {
45390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45391     return 0;
45392   }
45393   arg1 = *argp1;
45394   {
45395     try {
45396       result = Dali::BufferImage::DownCast(arg1);
45397     } catch (std::out_of_range& e) {
45398       {
45399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45400       };
45401     } catch (std::exception& e) {
45402       {
45403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (Dali::DaliException e) {
45406       {
45407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45408       };
45409     } catch (...) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45412       };
45413     }
45414   }
45415
45416   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45417   return jresult;
45418 }
45419
45420
45421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45422   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45423
45424   arg1 = (Dali::BufferImage *)jarg1;
45425   {
45426     try {
45427       delete arg1;
45428     } catch (std::out_of_range& e) {
45429       {
45430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45431       };
45432     } catch (std::exception& e) {
45433       {
45434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45435       };
45436     } catch (Dali::DaliException e) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45439       };
45440     } catch (...) {
45441       {
45442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45443       };
45444     }
45445   }
45446
45447 }
45448
45449
45450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45451   void * jresult ;
45452   Dali::BufferImage *arg1 = 0 ;
45453   Dali::BufferImage *result = 0 ;
45454
45455   arg1 = (Dali::BufferImage *)jarg1;
45456   if (!arg1) {
45457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45458     return 0;
45459   }
45460   {
45461     try {
45462       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45463     } catch (std::out_of_range& e) {
45464       {
45465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45466       };
45467     } catch (std::exception& e) {
45468       {
45469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (Dali::DaliException e) {
45472       {
45473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45474       };
45475     } catch (...) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45478       };
45479     }
45480   }
45481
45482   jresult = (void *)result;
45483   return jresult;
45484 }
45485
45486
45487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45488   void * jresult ;
45489   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45490   Dali::BufferImage *arg2 = 0 ;
45491   Dali::BufferImage *result = 0 ;
45492
45493   arg1 = (Dali::BufferImage *)jarg1;
45494   arg2 = (Dali::BufferImage *)jarg2;
45495   if (!arg2) {
45496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45497     return 0;
45498   }
45499   {
45500     try {
45501       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45502     } catch (std::out_of_range& e) {
45503       {
45504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45505       };
45506     } catch (std::exception& e) {
45507       {
45508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45509       };
45510     } catch (Dali::DaliException e) {
45511       {
45512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45513       };
45514     } catch (...) {
45515       {
45516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45517       };
45518     }
45519   }
45520
45521   jresult = (void *)result;
45522   return jresult;
45523 }
45524
45525
45526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45527   void * jresult ;
45528   Dali::BufferImage result;
45529
45530   {
45531     try {
45532       result = Dali::BufferImage::WHITE();
45533     } catch (std::out_of_range& e) {
45534       {
45535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45536       };
45537     } catch (std::exception& e) {
45538       {
45539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45540       };
45541     } catch (Dali::DaliException e) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45548       };
45549     }
45550   }
45551
45552   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45553   return jresult;
45554 }
45555
45556
45557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45558   void * jresult ;
45559   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45560   Dali::PixelBuffer *result = 0 ;
45561
45562   arg1 = (Dali::BufferImage *)jarg1;
45563   {
45564     try {
45565       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45566     } catch (std::out_of_range& e) {
45567       {
45568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45569       };
45570     } catch (std::exception& e) {
45571       {
45572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45573       };
45574     } catch (Dali::DaliException e) {
45575       {
45576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45577       };
45578     } catch (...) {
45579       {
45580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45581       };
45582     }
45583   }
45584
45585   jresult = (void *)result;
45586   return jresult;
45587 }
45588
45589
45590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45591   unsigned int jresult ;
45592   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45593   unsigned int result;
45594
45595   arg1 = (Dali::BufferImage *)jarg1;
45596   {
45597     try {
45598       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (Dali::DaliException e) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45610       };
45611     } catch (...) {
45612       {
45613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45614       };
45615     }
45616   }
45617
45618   jresult = result;
45619   return jresult;
45620 }
45621
45622
45623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45624   unsigned int jresult ;
45625   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45626   unsigned int result;
45627
45628   arg1 = (Dali::BufferImage *)jarg1;
45629   {
45630     try {
45631       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45632     } catch (std::out_of_range& e) {
45633       {
45634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (std::exception& e) {
45637       {
45638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45639       };
45640     } catch (Dali::DaliException e) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45643       };
45644     } catch (...) {
45645       {
45646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45647       };
45648     }
45649   }
45650
45651   jresult = result;
45652   return jresult;
45653 }
45654
45655
45656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45657   int jresult ;
45658   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45659   Dali::Pixel::Format result;
45660
45661   arg1 = (Dali::BufferImage *)jarg1;
45662   {
45663     try {
45664       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45680       };
45681     }
45682   }
45683
45684   jresult = (int)result;
45685   return jresult;
45686 }
45687
45688
45689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45690   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45691
45692   arg1 = (Dali::BufferImage *)jarg1;
45693   {
45694     try {
45695       (arg1)->Update();
45696     } catch (std::out_of_range& e) {
45697       {
45698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45699       };
45700     } catch (std::exception& e) {
45701       {
45702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45703       };
45704     } catch (Dali::DaliException e) {
45705       {
45706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45707       };
45708     } catch (...) {
45709       {
45710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45711       };
45712     }
45713   }
45714
45715 }
45716
45717
45718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45719   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45720   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45721   Dali::RectArea *argp2 ;
45722
45723   arg1 = (Dali::BufferImage *)jarg1;
45724   argp2 = (Dali::RectArea *)jarg2;
45725   if (!argp2) {
45726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45727     return ;
45728   }
45729   arg2 = *argp2;
45730   {
45731     try {
45732       (arg1)->Update(arg2);
45733     } catch (std::out_of_range& e) {
45734       {
45735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45736       };
45737     } catch (std::exception& e) {
45738       {
45739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45740       };
45741     } catch (Dali::DaliException e) {
45742       {
45743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45744       };
45745     } catch (...) {
45746       {
45747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45748       };
45749     }
45750   }
45751
45752 }
45753
45754
45755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45756   unsigned int jresult ;
45757   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45758   bool result;
45759
45760   arg1 = (Dali::BufferImage *)jarg1;
45761   {
45762     try {
45763       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45764     } catch (std::out_of_range& e) {
45765       {
45766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45767       };
45768     } catch (std::exception& e) {
45769       {
45770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45771       };
45772     } catch (Dali::DaliException e) {
45773       {
45774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45775       };
45776     } catch (...) {
45777       {
45778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45779       };
45780     }
45781   }
45782
45783   jresult = result;
45784   return jresult;
45785 }
45786
45787
45788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45789   void * jresult ;
45790   Dali::NativeImage *result = 0 ;
45791
45792   {
45793     try {
45794       result = (Dali::NativeImage *)new Dali::NativeImage();
45795     } catch (std::out_of_range& e) {
45796       {
45797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45798       };
45799     } catch (std::exception& e) {
45800       {
45801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45802       };
45803     } catch (Dali::DaliException e) {
45804       {
45805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45806       };
45807     } catch (...) {
45808       {
45809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45810       };
45811     }
45812   }
45813
45814   jresult = (void *)result;
45815   return jresult;
45816 }
45817
45818
45819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45820   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45821
45822   arg1 = (Dali::NativeImage *)jarg1;
45823   {
45824     try {
45825       delete arg1;
45826     } catch (std::out_of_range& e) {
45827       {
45828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45829       };
45830     } catch (std::exception& e) {
45831       {
45832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45833       };
45834     } catch (Dali::DaliException e) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45837       };
45838     } catch (...) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45841       };
45842     }
45843   }
45844
45845 }
45846
45847
45848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45849   void * jresult ;
45850   Dali::NativeImage *arg1 = 0 ;
45851   Dali::NativeImage *result = 0 ;
45852
45853   arg1 = (Dali::NativeImage *)jarg1;
45854   if (!arg1) {
45855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45856     return 0;
45857   }
45858   {
45859     try {
45860       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45861     } catch (std::out_of_range& e) {
45862       {
45863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45864       };
45865     } catch (std::exception& e) {
45866       {
45867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45868       };
45869     } catch (Dali::DaliException e) {
45870       {
45871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45872       };
45873     } catch (...) {
45874       {
45875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45876       };
45877     }
45878   }
45879
45880   jresult = (void *)result;
45881   return jresult;
45882 }
45883
45884
45885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45886   void * jresult ;
45887   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45888   Dali::NativeImage *arg2 = 0 ;
45889   Dali::NativeImage *result = 0 ;
45890
45891   arg1 = (Dali::NativeImage *)jarg1;
45892   arg2 = (Dali::NativeImage *)jarg2;
45893   if (!arg2) {
45894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45895     return 0;
45896   }
45897   {
45898     try {
45899       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
45900     } catch (std::out_of_range& e) {
45901       {
45902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45903       };
45904     } catch (std::exception& e) {
45905       {
45906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45907       };
45908     } catch (Dali::DaliException e) {
45909       {
45910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45911       };
45912     } catch (...) {
45913       {
45914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45915       };
45916     }
45917   }
45918
45919   jresult = (void *)result;
45920   return jresult;
45921 }
45922
45923
45924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45925   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45926
45927   arg1 = (Dali::NativeImage *)jarg1;
45928   {
45929     try {
45930       (arg1)->CreateGlTexture();
45931     } catch (std::out_of_range& e) {
45932       {
45933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45934       };
45935     } catch (std::exception& e) {
45936       {
45937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45938       };
45939     } catch (Dali::DaliException e) {
45940       {
45941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45942       };
45943     } catch (...) {
45944       {
45945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45946       };
45947     }
45948   }
45949
45950 }
45951
45952
45953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45954   void * jresult ;
45955   NativeImageInterface *arg1 = 0 ;
45956   Dali::NativeImage result;
45957
45958   arg1 = (NativeImageInterface *)jarg1;
45959   if (!arg1) {
45960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45961     return 0;
45962   }
45963   {
45964     try {
45965       result = Dali::NativeImage::New(*arg1);
45966     } catch (std::out_of_range& e) {
45967       {
45968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45969       };
45970     } catch (std::exception& e) {
45971       {
45972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45973       };
45974     } catch (Dali::DaliException e) {
45975       {
45976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45977       };
45978     } catch (...) {
45979       {
45980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45981       };
45982     }
45983   }
45984
45985   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45986   return jresult;
45987 }
45988
45989
45990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45991   void * jresult ;
45992   Dali::BaseHandle arg1 ;
45993   Dali::BaseHandle *argp1 ;
45994   Dali::NativeImage result;
45995
45996   argp1 = (Dali::BaseHandle *)jarg1;
45997   if (!argp1) {
45998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45999     return 0;
46000   }
46001   arg1 = *argp1;
46002   {
46003     try {
46004       result = Dali::NativeImage::DownCast(arg1);
46005     } catch (std::out_of_range& e) {
46006       {
46007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (std::exception& e) {
46010       {
46011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46012       };
46013     } catch (Dali::DaliException e) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46016       };
46017     } catch (...) {
46018       {
46019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46020       };
46021     }
46022   }
46023
46024   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46025   return jresult;
46026 }
46027
46028
46029 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46030   char * jresult ;
46031   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46032   char *result = 0 ;
46033
46034   arg1 = (Dali::NativeImage *)jarg1;
46035   {
46036     try {
46037       result = (char *)(arg1)->GetCustomFragmentPreFix();
46038     } catch (std::out_of_range& e) {
46039       {
46040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46041       };
46042     } catch (std::exception& e) {
46043       {
46044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46045       };
46046     } catch (Dali::DaliException e) {
46047       {
46048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46049       };
46050     } catch (...) {
46051       {
46052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46053       };
46054     }
46055   }
46056
46057   jresult = SWIG_csharp_string_callback((const char *)result);
46058   return jresult;
46059 }
46060
46061
46062 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46063   char * jresult ;
46064   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46065   char *result = 0 ;
46066
46067   arg1 = (Dali::NativeImage *)jarg1;
46068   {
46069     try {
46070       result = (char *)(arg1)->GetCustomSamplerTypename();
46071     } catch (std::out_of_range& e) {
46072       {
46073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46074       };
46075     } catch (std::exception& e) {
46076       {
46077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46078       };
46079     } catch (Dali::DaliException e) {
46080       {
46081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46082       };
46083     } catch (...) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46086       };
46087     }
46088   }
46089
46090   jresult = SWIG_csharp_string_callback((const char *)result);
46091   return jresult;
46092 }
46093
46094
46095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46096   unsigned int jresult ;
46097   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46098   bool result;
46099
46100   arg1 = (Dali::NativeImageInterface *)jarg1;
46101   {
46102     try {
46103       result = (bool)(arg1)->GlExtensionCreate();
46104     } catch (std::out_of_range& e) {
46105       {
46106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46107       };
46108     } catch (std::exception& e) {
46109       {
46110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46111       };
46112     } catch (Dali::DaliException e) {
46113       {
46114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46115       };
46116     } catch (...) {
46117       {
46118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46119       };
46120     }
46121   }
46122
46123   jresult = result;
46124   return jresult;
46125 }
46126
46127
46128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46129   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46130
46131   arg1 = (Dali::NativeImageInterface *)jarg1;
46132   {
46133     try {
46134       (arg1)->GlExtensionDestroy();
46135     } catch (std::out_of_range& e) {
46136       {
46137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46138       };
46139     } catch (std::exception& e) {
46140       {
46141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46142       };
46143     } catch (Dali::DaliException e) {
46144       {
46145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46146       };
46147     } catch (...) {
46148       {
46149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46150       };
46151     }
46152   }
46153
46154 }
46155
46156
46157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46158   unsigned int jresult ;
46159   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46160   unsigned int result;
46161
46162   arg1 = (Dali::NativeImageInterface *)jarg1;
46163   {
46164     try {
46165       result = (unsigned int)(arg1)->TargetTexture();
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 = result;
46186   return jresult;
46187 }
46188
46189
46190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46191   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46192
46193   arg1 = (Dali::NativeImageInterface *)jarg1;
46194   {
46195     try {
46196       (arg1)->PrepareTexture();
46197     } catch (std::out_of_range& e) {
46198       {
46199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46200       };
46201     } catch (std::exception& e) {
46202       {
46203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46204       };
46205     } catch (Dali::DaliException e) {
46206       {
46207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46208       };
46209     } catch (...) {
46210       {
46211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46212       };
46213     }
46214   }
46215
46216 }
46217
46218
46219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46220   unsigned int jresult ;
46221   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46222   unsigned int result;
46223
46224   arg1 = (Dali::NativeImageInterface *)jarg1;
46225   {
46226     try {
46227       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46228     } catch (std::out_of_range& e) {
46229       {
46230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46231       };
46232     } catch (std::exception& e) {
46233       {
46234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46235       };
46236     } catch (Dali::DaliException e) {
46237       {
46238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46239       };
46240     } catch (...) {
46241       {
46242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46243       };
46244     }
46245   }
46246
46247   jresult = result;
46248   return jresult;
46249 }
46250
46251
46252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46253   unsigned int jresult ;
46254   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46255   unsigned int result;
46256
46257   arg1 = (Dali::NativeImageInterface *)jarg1;
46258   {
46259     try {
46260       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46261     } catch (std::out_of_range& e) {
46262       {
46263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46264       };
46265     } catch (std::exception& e) {
46266       {
46267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46268       };
46269     } catch (Dali::DaliException e) {
46270       {
46271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46272       };
46273     } catch (...) {
46274       {
46275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46276       };
46277     }
46278   }
46279
46280   jresult = result;
46281   return jresult;
46282 }
46283
46284
46285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46286   unsigned int jresult ;
46287   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46288   bool result;
46289
46290   arg1 = (Dali::NativeImageInterface *)jarg1;
46291   {
46292     try {
46293       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46294     } catch (std::out_of_range& e) {
46295       {
46296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46297       };
46298     } catch (std::exception& e) {
46299       {
46300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46301       };
46302     } catch (Dali::DaliException e) {
46303       {
46304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46305       };
46306     } catch (...) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46309       };
46310     }
46311   }
46312
46313   jresult = result;
46314   return jresult;
46315 }
46316
46317
46318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46319   void * jresult ;
46320   std::string *arg1 = 0 ;
46321   Dali::ImageDimensions result;
46322
46323   if (!jarg1) {
46324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46325     return 0;
46326   }
46327   std::string arg1_str(jarg1);
46328   arg1 = &arg1_str;
46329   {
46330     try {
46331       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46332     } catch (std::out_of_range& e) {
46333       {
46334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46335       };
46336     } catch (std::exception& e) {
46337       {
46338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46339       };
46340     } catch (Dali::DaliException e) {
46341       {
46342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46343       };
46344     } catch (...) {
46345       {
46346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46347       };
46348     }
46349   }
46350
46351   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46352
46353   //argout typemap for const std::string&
46354
46355   return jresult;
46356 }
46357
46358
46359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46360   void * jresult ;
46361   Dali::ResourceImage *result = 0 ;
46362
46363   {
46364     try {
46365       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46366     } catch (std::out_of_range& e) {
46367       {
46368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46369       };
46370     } catch (std::exception& e) {
46371       {
46372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46373       };
46374     } catch (Dali::DaliException e) {
46375       {
46376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46377       };
46378     } catch (...) {
46379       {
46380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46381       };
46382     }
46383   }
46384
46385   jresult = (void *)result;
46386   return jresult;
46387 }
46388
46389
46390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46391   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46392
46393   arg1 = (Dali::ResourceImage *)jarg1;
46394   {
46395     try {
46396       delete arg1;
46397     } catch (std::out_of_range& e) {
46398       {
46399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46400       };
46401     } catch (std::exception& e) {
46402       {
46403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46404       };
46405     } catch (Dali::DaliException e) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46408       };
46409     } catch (...) {
46410       {
46411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46412       };
46413     }
46414   }
46415
46416 }
46417
46418
46419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46420   void * jresult ;
46421   Dali::ResourceImage *arg1 = 0 ;
46422   Dali::ResourceImage *result = 0 ;
46423
46424   arg1 = (Dali::ResourceImage *)jarg1;
46425   if (!arg1) {
46426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46427     return 0;
46428   }
46429   {
46430     try {
46431       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46432     } catch (std::out_of_range& e) {
46433       {
46434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46435       };
46436     } catch (std::exception& e) {
46437       {
46438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46439       };
46440     } catch (Dali::DaliException e) {
46441       {
46442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46443       };
46444     } catch (...) {
46445       {
46446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46447       };
46448     }
46449   }
46450
46451   jresult = (void *)result;
46452   return jresult;
46453 }
46454
46455
46456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46457   void * jresult ;
46458   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46459   Dali::ResourceImage *arg2 = 0 ;
46460   Dali::ResourceImage *result = 0 ;
46461
46462   arg1 = (Dali::ResourceImage *)jarg1;
46463   arg2 = (Dali::ResourceImage *)jarg2;
46464   if (!arg2) {
46465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46466     return 0;
46467   }
46468   {
46469     try {
46470       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
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 = (void *)result;
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46496   void * jresult ;
46497   std::string *arg1 = 0 ;
46498   bool arg2 ;
46499   Dali::ResourceImage result;
46500
46501   if (!jarg1) {
46502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46503     return 0;
46504   }
46505   std::string arg1_str(jarg1);
46506   arg1 = &arg1_str;
46507   arg2 = jarg2 ? true : false;
46508   {
46509     try {
46510       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46511     } catch (std::out_of_range& e) {
46512       {
46513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (std::exception& e) {
46516       {
46517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (Dali::DaliException e) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46522       };
46523     } catch (...) {
46524       {
46525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46526       };
46527     }
46528   }
46529
46530   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46531
46532   //argout typemap for const std::string&
46533
46534   return jresult;
46535 }
46536
46537
46538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46539   void * jresult ;
46540   std::string *arg1 = 0 ;
46541   Dali::ResourceImage result;
46542
46543   if (!jarg1) {
46544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46545     return 0;
46546   }
46547   std::string arg1_str(jarg1);
46548   arg1 = &arg1_str;
46549   {
46550     try {
46551       result = Dali::ResourceImage::New((std::string const &)*arg1);
46552     } catch (std::out_of_range& e) {
46553       {
46554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46555       };
46556     } catch (std::exception& e) {
46557       {
46558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46559       };
46560     } catch (Dali::DaliException e) {
46561       {
46562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46563       };
46564     } catch (...) {
46565       {
46566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46567       };
46568     }
46569   }
46570
46571   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46572
46573   //argout typemap for const std::string&
46574
46575   return jresult;
46576 }
46577
46578
46579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46580   void * jresult ;
46581   std::string *arg1 = 0 ;
46582   Dali::ImageDimensions arg2 ;
46583   Dali::FittingMode::Type arg3 ;
46584   Dali::SamplingMode::Type arg4 ;
46585   bool arg5 ;
46586   Dali::ImageDimensions *argp2 ;
46587   Dali::ResourceImage result;
46588
46589   if (!jarg1) {
46590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46591     return 0;
46592   }
46593   std::string arg1_str(jarg1);
46594   arg1 = &arg1_str;
46595   argp2 = (Dali::ImageDimensions *)jarg2;
46596   if (!argp2) {
46597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46598     return 0;
46599   }
46600   arg2 = *argp2;
46601   arg3 = (Dali::FittingMode::Type)jarg3;
46602   arg4 = (Dali::SamplingMode::Type)jarg4;
46603   arg5 = jarg5 ? true : false;
46604   {
46605     try {
46606       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46607     } catch (std::out_of_range& e) {
46608       {
46609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46610       };
46611     } catch (std::exception& e) {
46612       {
46613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46614       };
46615     } catch (Dali::DaliException e) {
46616       {
46617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46618       };
46619     } catch (...) {
46620       {
46621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46622       };
46623     }
46624   }
46625
46626   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46627
46628   //argout typemap for const std::string&
46629
46630   return jresult;
46631 }
46632
46633
46634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46635   void * jresult ;
46636   std::string *arg1 = 0 ;
46637   Dali::ImageDimensions arg2 ;
46638   Dali::FittingMode::Type arg3 ;
46639   Dali::SamplingMode::Type arg4 ;
46640   Dali::ImageDimensions *argp2 ;
46641   Dali::ResourceImage result;
46642
46643   if (!jarg1) {
46644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46645     return 0;
46646   }
46647   std::string arg1_str(jarg1);
46648   arg1 = &arg1_str;
46649   argp2 = (Dali::ImageDimensions *)jarg2;
46650   if (!argp2) {
46651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46652     return 0;
46653   }
46654   arg2 = *argp2;
46655   arg3 = (Dali::FittingMode::Type)jarg3;
46656   arg4 = (Dali::SamplingMode::Type)jarg4;
46657   {
46658     try {
46659       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46660     } catch (std::out_of_range& e) {
46661       {
46662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46663       };
46664     } catch (std::exception& e) {
46665       {
46666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (Dali::DaliException e) {
46669       {
46670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46671       };
46672     } catch (...) {
46673       {
46674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46675       };
46676     }
46677   }
46678
46679   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46680
46681   //argout typemap for const std::string&
46682
46683   return jresult;
46684 }
46685
46686
46687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46688   void * jresult ;
46689   std::string *arg1 = 0 ;
46690   Dali::ImageDimensions arg2 ;
46691   Dali::FittingMode::Type arg3 ;
46692   Dali::ImageDimensions *argp2 ;
46693   Dali::ResourceImage result;
46694
46695   if (!jarg1) {
46696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46697     return 0;
46698   }
46699   std::string arg1_str(jarg1);
46700   arg1 = &arg1_str;
46701   argp2 = (Dali::ImageDimensions *)jarg2;
46702   if (!argp2) {
46703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46704     return 0;
46705   }
46706   arg2 = *argp2;
46707   arg3 = (Dali::FittingMode::Type)jarg3;
46708   {
46709     try {
46710       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46711     } catch (std::out_of_range& e) {
46712       {
46713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46714       };
46715     } catch (std::exception& e) {
46716       {
46717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46718       };
46719     } catch (Dali::DaliException e) {
46720       {
46721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46722       };
46723     } catch (...) {
46724       {
46725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46726       };
46727     }
46728   }
46729
46730   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46731
46732   //argout typemap for const std::string&
46733
46734   return jresult;
46735 }
46736
46737
46738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46739   void * jresult ;
46740   std::string *arg1 = 0 ;
46741   Dali::ImageDimensions arg2 ;
46742   Dali::ImageDimensions *argp2 ;
46743   Dali::ResourceImage result;
46744
46745   if (!jarg1) {
46746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46747     return 0;
46748   }
46749   std::string arg1_str(jarg1);
46750   arg1 = &arg1_str;
46751   argp2 = (Dali::ImageDimensions *)jarg2;
46752   if (!argp2) {
46753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46754     return 0;
46755   }
46756   arg2 = *argp2;
46757   {
46758     try {
46759       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46760     } catch (std::out_of_range& e) {
46761       {
46762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46763       };
46764     } catch (std::exception& e) {
46765       {
46766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46767       };
46768     } catch (Dali::DaliException e) {
46769       {
46770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46771       };
46772     } catch (...) {
46773       {
46774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46775       };
46776     }
46777   }
46778
46779   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46780
46781   //argout typemap for const std::string&
46782
46783   return jresult;
46784 }
46785
46786
46787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46788   void * jresult ;
46789   Dali::BaseHandle arg1 ;
46790   Dali::BaseHandle *argp1 ;
46791   Dali::ResourceImage result;
46792
46793   argp1 = (Dali::BaseHandle *)jarg1;
46794   if (!argp1) {
46795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46796     return 0;
46797   }
46798   arg1 = *argp1;
46799   {
46800     try {
46801       result = Dali::ResourceImage::DownCast(arg1);
46802     } catch (std::out_of_range& e) {
46803       {
46804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46805       };
46806     } catch (std::exception& e) {
46807       {
46808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46809       };
46810     } catch (Dali::DaliException e) {
46811       {
46812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46813       };
46814     } catch (...) {
46815       {
46816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46817       };
46818     }
46819   }
46820
46821   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46822   return jresult;
46823 }
46824
46825
46826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46827   int jresult ;
46828   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46829   Dali::LoadingState result;
46830
46831   arg1 = (Dali::ResourceImage *)jarg1;
46832   {
46833     try {
46834       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46835     } catch (std::out_of_range& e) {
46836       {
46837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46838       };
46839     } catch (std::exception& e) {
46840       {
46841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46842       };
46843     } catch (Dali::DaliException e) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46846       };
46847     } catch (...) {
46848       {
46849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46850       };
46851     }
46852   }
46853
46854   jresult = (int)result;
46855   return jresult;
46856 }
46857
46858
46859 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46860   char * jresult ;
46861   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46862   std::string result;
46863
46864   arg1 = (Dali::ResourceImage *)jarg1;
46865   {
46866     try {
46867       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46868     } catch (std::out_of_range& e) {
46869       {
46870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46871       };
46872     } catch (std::exception& e) {
46873       {
46874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46875       };
46876     } catch (Dali::DaliException e) {
46877       {
46878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46879       };
46880     } catch (...) {
46881       {
46882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46883       };
46884     }
46885   }
46886
46887   jresult = SWIG_csharp_string_callback((&result)->c_str());
46888   return jresult;
46889 }
46890
46891
46892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
46893   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46894
46895   arg1 = (Dali::ResourceImage *)jarg1;
46896   {
46897     try {
46898       (arg1)->Reload();
46899     } catch (std::out_of_range& e) {
46900       {
46901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46902       };
46903     } catch (std::exception& e) {
46904       {
46905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46906       };
46907     } catch (Dali::DaliException e) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46910       };
46911     } catch (...) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46914       };
46915     }
46916   }
46917
46918 }
46919
46920
46921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
46922   void * jresult ;
46923   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46924   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46925
46926   arg1 = (Dali::ResourceImage *)jarg1;
46927   {
46928     try {
46929       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46930     } catch (std::out_of_range& e) {
46931       {
46932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46933       };
46934     } catch (std::exception& e) {
46935       {
46936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46937       };
46938     } catch (Dali::DaliException e) {
46939       {
46940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46941       };
46942     } catch (...) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46945       };
46946     }
46947   }
46948
46949   jresult = (void *)result;
46950   return jresult;
46951 }
46952
46953
46954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46955   void * jresult ;
46956   Dali::FrameBufferImage *result = 0 ;
46957
46958   {
46959     try {
46960       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46961     } catch (std::out_of_range& e) {
46962       {
46963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46964       };
46965     } catch (std::exception& e) {
46966       {
46967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46968       };
46969     } catch (Dali::DaliException e) {
46970       {
46971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46972       };
46973     } catch (...) {
46974       {
46975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46976       };
46977     }
46978   }
46979
46980   jresult = (void *)result;
46981   return jresult;
46982 }
46983
46984
46985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46986   void * jresult ;
46987   unsigned int arg1 ;
46988   unsigned int arg2 ;
46989   Dali::Pixel::Format arg3 ;
46990   Dali::RenderBuffer::Format arg4 ;
46991   Dali::FrameBufferImage result;
46992
46993   arg1 = (unsigned int)jarg1;
46994   arg2 = (unsigned int)jarg2;
46995   arg3 = (Dali::Pixel::Format)jarg3;
46996   arg4 = (Dali::RenderBuffer::Format)jarg4;
46997   {
46998     try {
46999       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47000     } catch (std::out_of_range& e) {
47001       {
47002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47003       };
47004     } catch (std::exception& e) {
47005       {
47006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47007       };
47008     } catch (Dali::DaliException e) {
47009       {
47010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47011       };
47012     } catch (...) {
47013       {
47014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47015       };
47016     }
47017   }
47018
47019   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47020   return jresult;
47021 }
47022
47023
47024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47025   void * jresult ;
47026   unsigned int arg1 ;
47027   unsigned int arg2 ;
47028   Dali::Pixel::Format arg3 ;
47029   Dali::FrameBufferImage result;
47030
47031   arg1 = (unsigned int)jarg1;
47032   arg2 = (unsigned int)jarg2;
47033   arg3 = (Dali::Pixel::Format)jarg3;
47034   {
47035     try {
47036       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47037     } catch (std::out_of_range& e) {
47038       {
47039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47040       };
47041     } catch (std::exception& e) {
47042       {
47043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47044       };
47045     } catch (Dali::DaliException e) {
47046       {
47047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47048       };
47049     } catch (...) {
47050       {
47051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47052       };
47053     }
47054   }
47055
47056   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47057   return jresult;
47058 }
47059
47060
47061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47062   void * jresult ;
47063   unsigned int arg1 ;
47064   unsigned int arg2 ;
47065   Dali::FrameBufferImage result;
47066
47067   arg1 = (unsigned int)jarg1;
47068   arg2 = (unsigned int)jarg2;
47069   {
47070     try {
47071       result = Dali::FrameBufferImage::New(arg1,arg2);
47072     } catch (std::out_of_range& e) {
47073       {
47074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47075       };
47076     } catch (std::exception& e) {
47077       {
47078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47079       };
47080     } catch (Dali::DaliException e) {
47081       {
47082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47083       };
47084     } catch (...) {
47085       {
47086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47087       };
47088     }
47089   }
47090
47091   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47092   return jresult;
47093 }
47094
47095
47096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47097   void * jresult ;
47098   unsigned int arg1 ;
47099   Dali::FrameBufferImage result;
47100
47101   arg1 = (unsigned int)jarg1;
47102   {
47103     try {
47104       result = Dali::FrameBufferImage::New(arg1);
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47112       };
47113     } catch (Dali::DaliException e) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47116       };
47117     } catch (...) {
47118       {
47119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47120       };
47121     }
47122   }
47123
47124   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47130   void * jresult ;
47131   Dali::FrameBufferImage result;
47132
47133   {
47134     try {
47135       result = Dali::FrameBufferImage::New();
47136     } catch (std::out_of_range& e) {
47137       {
47138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47139       };
47140     } catch (std::exception& e) {
47141       {
47142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47143       };
47144     } catch (Dali::DaliException e) {
47145       {
47146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47147       };
47148     } catch (...) {
47149       {
47150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47151       };
47152     }
47153   }
47154
47155   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47156   return jresult;
47157 }
47158
47159
47160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47161   void * jresult ;
47162   Dali::NativeImageInterface *arg1 = 0 ;
47163   Dali::FrameBufferImage result;
47164
47165   arg1 = (Dali::NativeImageInterface *)jarg1;
47166   if (!arg1) {
47167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47168     return 0;
47169   }
47170   {
47171     try {
47172       result = Dali::FrameBufferImage::New(*arg1);
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 = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47193   return jresult;
47194 }
47195
47196
47197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47198   void * jresult ;
47199   Dali::BaseHandle arg1 ;
47200   Dali::BaseHandle *argp1 ;
47201   Dali::FrameBufferImage result;
47202
47203   argp1 = (Dali::BaseHandle *)jarg1;
47204   if (!argp1) {
47205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47206     return 0;
47207   }
47208   arg1 = *argp1;
47209   {
47210     try {
47211       result = Dali::FrameBufferImage::DownCast(arg1);
47212     } catch (std::out_of_range& e) {
47213       {
47214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (std::exception& e) {
47217       {
47218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47219       };
47220     } catch (Dali::DaliException e) {
47221       {
47222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47223       };
47224     } catch (...) {
47225       {
47226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47227       };
47228     }
47229   }
47230
47231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47232   return jresult;
47233 }
47234
47235
47236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47237   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47238
47239   arg1 = (Dali::FrameBufferImage *)jarg1;
47240   {
47241     try {
47242       delete arg1;
47243     } catch (std::out_of_range& e) {
47244       {
47245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47246       };
47247     } catch (std::exception& e) {
47248       {
47249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47250       };
47251     } catch (Dali::DaliException e) {
47252       {
47253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47254       };
47255     } catch (...) {
47256       {
47257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47258       };
47259     }
47260   }
47261
47262 }
47263
47264
47265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47266   void * jresult ;
47267   Dali::FrameBufferImage *arg1 = 0 ;
47268   Dali::FrameBufferImage *result = 0 ;
47269
47270   arg1 = (Dali::FrameBufferImage *)jarg1;
47271   if (!arg1) {
47272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47273     return 0;
47274   }
47275   {
47276     try {
47277       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47278     } catch (std::out_of_range& e) {
47279       {
47280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47281       };
47282     } catch (std::exception& e) {
47283       {
47284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47285       };
47286     } catch (Dali::DaliException e) {
47287       {
47288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47289       };
47290     } catch (...) {
47291       {
47292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47293       };
47294     }
47295   }
47296
47297   jresult = (void *)result;
47298   return jresult;
47299 }
47300
47301
47302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47303   void * jresult ;
47304   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47305   Dali::FrameBufferImage *arg2 = 0 ;
47306   Dali::FrameBufferImage *result = 0 ;
47307
47308   arg1 = (Dali::FrameBufferImage *)jarg1;
47309   arg2 = (Dali::FrameBufferImage *)jarg2;
47310   if (!arg2) {
47311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47312     return 0;
47313   }
47314   {
47315     try {
47316       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47317     } catch (std::out_of_range& e) {
47318       {
47319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47320       };
47321     } catch (std::exception& e) {
47322       {
47323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (Dali::DaliException e) {
47326       {
47327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335
47336   jresult = (void *)result;
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47342   void * jresult ;
47343   Dali::NinePatchImage *result = 0 ;
47344
47345   {
47346     try {
47347       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47348     } catch (std::out_of_range& e) {
47349       {
47350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47351       };
47352     } catch (std::exception& e) {
47353       {
47354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47355       };
47356     } catch (Dali::DaliException e) {
47357       {
47358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47359       };
47360     } catch (...) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47363       };
47364     }
47365   }
47366
47367   jresult = (void *)result;
47368   return jresult;
47369 }
47370
47371
47372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47373   void * jresult ;
47374   std::string *arg1 = 0 ;
47375   Dali::NinePatchImage result;
47376
47377   if (!jarg1) {
47378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47379     return 0;
47380   }
47381   std::string arg1_str(jarg1);
47382   arg1 = &arg1_str;
47383   {
47384     try {
47385       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47386     } catch (std::out_of_range& e) {
47387       {
47388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47389       };
47390     } catch (std::exception& e) {
47391       {
47392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47393       };
47394     } catch (Dali::DaliException e) {
47395       {
47396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47397       };
47398     } catch (...) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47401       };
47402     }
47403   }
47404
47405   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47406
47407   //argout typemap for const std::string&
47408
47409   return jresult;
47410 }
47411
47412
47413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47414   void * jresult ;
47415   Dali::BaseHandle arg1 ;
47416   Dali::BaseHandle *argp1 ;
47417   Dali::NinePatchImage result;
47418
47419   argp1 = (Dali::BaseHandle *)jarg1;
47420   if (!argp1) {
47421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47422     return 0;
47423   }
47424   arg1 = *argp1;
47425   {
47426     try {
47427       result = Dali::NinePatchImage::DownCast(arg1);
47428     } catch (std::out_of_range& e) {
47429       {
47430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47431       };
47432     } catch (std::exception& e) {
47433       {
47434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47435       };
47436     } catch (Dali::DaliException e) {
47437       {
47438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47439       };
47440     } catch (...) {
47441       {
47442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47443       };
47444     }
47445   }
47446
47447   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47448   return jresult;
47449 }
47450
47451
47452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47453   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47454
47455   arg1 = (Dali::NinePatchImage *)jarg1;
47456   {
47457     try {
47458       delete arg1;
47459     } catch (std::out_of_range& e) {
47460       {
47461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47462       };
47463     } catch (std::exception& e) {
47464       {
47465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47466       };
47467     } catch (Dali::DaliException e) {
47468       {
47469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47470       };
47471     } catch (...) {
47472       {
47473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47474       };
47475     }
47476   }
47477
47478 }
47479
47480
47481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47482   void * jresult ;
47483   Dali::NinePatchImage *arg1 = 0 ;
47484   Dali::NinePatchImage *result = 0 ;
47485
47486   arg1 = (Dali::NinePatchImage *)jarg1;
47487   if (!arg1) {
47488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47489     return 0;
47490   }
47491   {
47492     try {
47493       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47494     } catch (std::out_of_range& e) {
47495       {
47496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47497       };
47498     } catch (std::exception& e) {
47499       {
47500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47501       };
47502     } catch (Dali::DaliException e) {
47503       {
47504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47505       };
47506     } catch (...) {
47507       {
47508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47509       };
47510     }
47511   }
47512
47513   jresult = (void *)result;
47514   return jresult;
47515 }
47516
47517
47518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47519   void * jresult ;
47520   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47521   Dali::NinePatchImage *arg2 = 0 ;
47522   Dali::NinePatchImage *result = 0 ;
47523
47524   arg1 = (Dali::NinePatchImage *)jarg1;
47525   arg2 = (Dali::NinePatchImage *)jarg2;
47526   if (!arg2) {
47527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47528     return 0;
47529   }
47530   {
47531     try {
47532       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47533     } catch (std::out_of_range& e) {
47534       {
47535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47536       };
47537     } catch (std::exception& e) {
47538       {
47539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47540       };
47541     } catch (Dali::DaliException e) {
47542       {
47543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47544       };
47545     } catch (...) {
47546       {
47547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47548       };
47549     }
47550   }
47551
47552   jresult = (void *)result;
47553   return jresult;
47554 }
47555
47556
47557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47558   void * jresult ;
47559   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47560   Dali::Vector4 result;
47561
47562   arg1 = (Dali::NinePatchImage *)jarg1;
47563   {
47564     try {
47565       result = (arg1)->GetStretchBorders();
47566     } catch (std::out_of_range& e) {
47567       {
47568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47569       };
47570     } catch (std::exception& e) {
47571       {
47572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47573       };
47574     } catch (Dali::DaliException e) {
47575       {
47576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47577       };
47578     } catch (...) {
47579       {
47580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47581       };
47582     }
47583   }
47584
47585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47586   return jresult;
47587 }
47588
47589
47590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47591   void * jresult ;
47592   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47593   Dali::NinePatchImage::StretchRanges *result = 0 ;
47594
47595   arg1 = (Dali::NinePatchImage *)jarg1;
47596   {
47597     try {
47598       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47599     } catch (std::out_of_range& e) {
47600       {
47601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47602       };
47603     } catch (std::exception& e) {
47604       {
47605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47606       };
47607     } catch (Dali::DaliException e) {
47608       {
47609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47610       };
47611     } catch (...) {
47612       {
47613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47614       };
47615     }
47616   }
47617
47618   jresult = (void *)result;
47619   return jresult;
47620 }
47621
47622
47623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47624   void * jresult ;
47625   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47626   Dali::NinePatchImage::StretchRanges *result = 0 ;
47627
47628   arg1 = (Dali::NinePatchImage *)jarg1;
47629   {
47630     try {
47631       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47632     } catch (std::out_of_range& e) {
47633       {
47634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47635       };
47636     } catch (std::exception& e) {
47637       {
47638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47639       };
47640     } catch (Dali::DaliException e) {
47641       {
47642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47643       };
47644     } catch (...) {
47645       {
47646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47647       };
47648     }
47649   }
47650
47651   jresult = (void *)result;
47652   return jresult;
47653 }
47654
47655
47656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47657   void * jresult ;
47658   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47659   Dali::Rect< int > result;
47660
47661   arg1 = (Dali::NinePatchImage *)jarg1;
47662   {
47663     try {
47664       result = (arg1)->GetChildRectangle();
47665     } catch (std::out_of_range& e) {
47666       {
47667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47668       };
47669     } catch (std::exception& e) {
47670       {
47671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47672       };
47673     } catch (Dali::DaliException e) {
47674       {
47675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47676       };
47677     } catch (...) {
47678       {
47679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47680       };
47681     }
47682   }
47683
47684   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47685   return jresult;
47686 }
47687
47688
47689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47690   void * jresult ;
47691   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47692   Dali::BufferImage result;
47693
47694   arg1 = (Dali::NinePatchImage *)jarg1;
47695   {
47696     try {
47697       result = (arg1)->CreateCroppedBufferImage();
47698     } catch (std::out_of_range& e) {
47699       {
47700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47701       };
47702     } catch (std::exception& e) {
47703       {
47704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47705       };
47706     } catch (Dali::DaliException e) {
47707       {
47708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47709       };
47710     } catch (...) {
47711       {
47712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47713       };
47714     }
47715   }
47716
47717   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47718   return jresult;
47719 }
47720
47721
47722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47723   unsigned int jresult ;
47724   std::string *arg1 = 0 ;
47725   bool result;
47726
47727   if (!jarg1) {
47728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47729     return 0;
47730   }
47731   std::string arg1_str(jarg1);
47732   arg1 = &arg1_str;
47733   {
47734     try {
47735       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47736     } catch (std::out_of_range& e) {
47737       {
47738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47739       };
47740     } catch (std::exception& e) {
47741       {
47742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (Dali::DaliException e) {
47745       {
47746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47747       };
47748     } catch (...) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47751       };
47752     }
47753   }
47754
47755   jresult = result;
47756
47757   //argout typemap for const std::string&
47758
47759   return jresult;
47760 }
47761
47762
47763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47764   int jresult ;
47765   int result;
47766
47767   result = (int)Dali::CameraActor::Property::TYPE;
47768   jresult = (int)result;
47769   return jresult;
47770 }
47771
47772
47773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47774   int jresult ;
47775   int result;
47776
47777   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47778   jresult = (int)result;
47779   return jresult;
47780 }
47781
47782
47783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47784   int jresult ;
47785   int result;
47786
47787   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47788   jresult = (int)result;
47789   return jresult;
47790 }
47791
47792
47793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47794   int jresult ;
47795   int result;
47796
47797   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47798   jresult = (int)result;
47799   return jresult;
47800 }
47801
47802
47803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47804   int jresult ;
47805   int result;
47806
47807   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47808   jresult = (int)result;
47809   return jresult;
47810 }
47811
47812
47813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47814   int jresult ;
47815   int result;
47816
47817   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47818   jresult = (int)result;
47819   return jresult;
47820 }
47821
47822
47823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47824   int jresult ;
47825   int result;
47826
47827   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47828   jresult = (int)result;
47829   return jresult;
47830 }
47831
47832
47833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47834   int jresult ;
47835   int result;
47836
47837   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47838   jresult = (int)result;
47839   return jresult;
47840 }
47841
47842
47843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47844   int jresult ;
47845   int result;
47846
47847   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47848   jresult = (int)result;
47849   return jresult;
47850 }
47851
47852
47853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47854   int jresult ;
47855   int result;
47856
47857   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47858   jresult = (int)result;
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
47864   int jresult ;
47865   int result;
47866
47867   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
47868   jresult = (int)result;
47869   return jresult;
47870 }
47871
47872
47873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
47874   int jresult ;
47875   int result;
47876
47877   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
47878   jresult = (int)result;
47879   return jresult;
47880 }
47881
47882
47883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
47884   int jresult ;
47885   int result;
47886
47887   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
47888   jresult = (int)result;
47889   return jresult;
47890 }
47891
47892
47893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
47894   int jresult ;
47895   int result;
47896
47897   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
47898   jresult = (int)result;
47899   return jresult;
47900 }
47901
47902
47903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
47904   void * jresult ;
47905   Dali::CameraActor::Property *result = 0 ;
47906
47907   {
47908     try {
47909       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
47910     } catch (std::out_of_range& e) {
47911       {
47912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47913       };
47914     } catch (std::exception& e) {
47915       {
47916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47917       };
47918     } catch (Dali::DaliException e) {
47919       {
47920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47921       };
47922     } catch (...) {
47923       {
47924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47925       };
47926     }
47927   }
47928
47929   jresult = (void *)result;
47930   return jresult;
47931 }
47932
47933
47934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
47935   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
47936
47937   arg1 = (Dali::CameraActor::Property *)jarg1;
47938   {
47939     try {
47940       delete arg1;
47941     } catch (std::out_of_range& e) {
47942       {
47943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47944       };
47945     } catch (std::exception& e) {
47946       {
47947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47948       };
47949     } catch (Dali::DaliException e) {
47950       {
47951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47952       };
47953     } catch (...) {
47954       {
47955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47956       };
47957     }
47958   }
47959
47960 }
47961
47962
47963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
47964   void * jresult ;
47965   Dali::CameraActor *result = 0 ;
47966
47967   {
47968     try {
47969       result = (Dali::CameraActor *)new Dali::CameraActor();
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 = (void *)result;
47990   return jresult;
47991 }
47992
47993
47994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
47995   void * jresult ;
47996   Dali::CameraActor result;
47997
47998   {
47999     try {
48000       result = Dali::CameraActor::New();
48001     } catch (std::out_of_range& e) {
48002       {
48003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48004       };
48005     } catch (std::exception& e) {
48006       {
48007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48008       };
48009     } catch (Dali::DaliException e) {
48010       {
48011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48012       };
48013     } catch (...) {
48014       {
48015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48016       };
48017     }
48018   }
48019
48020   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48021   return jresult;
48022 }
48023
48024
48025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48026   void * jresult ;
48027   Dali::Size *arg1 = 0 ;
48028   Dali::CameraActor result;
48029
48030   arg1 = (Dali::Size *)jarg1;
48031   if (!arg1) {
48032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48033     return 0;
48034   }
48035   {
48036     try {
48037       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48038     } catch (std::out_of_range& e) {
48039       {
48040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48041       };
48042     } catch (std::exception& e) {
48043       {
48044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48045       };
48046     } catch (Dali::DaliException e) {
48047       {
48048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48049       };
48050     } catch (...) {
48051       {
48052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48053       };
48054     }
48055   }
48056
48057   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48058   return jresult;
48059 }
48060
48061
48062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48063   void * jresult ;
48064   Dali::BaseHandle arg1 ;
48065   Dali::BaseHandle *argp1 ;
48066   Dali::CameraActor result;
48067
48068   argp1 = (Dali::BaseHandle *)jarg1;
48069   if (!argp1) {
48070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48071     return 0;
48072   }
48073   arg1 = *argp1;
48074   {
48075     try {
48076       result = Dali::CameraActor::DownCast(arg1);
48077     } catch (std::out_of_range& e) {
48078       {
48079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48080       };
48081     } catch (std::exception& e) {
48082       {
48083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48084       };
48085     } catch (Dali::DaliException e) {
48086       {
48087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48088       };
48089     } catch (...) {
48090       {
48091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48092       };
48093     }
48094   }
48095
48096   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48097   return jresult;
48098 }
48099
48100
48101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48102   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48103
48104   arg1 = (Dali::CameraActor *)jarg1;
48105   {
48106     try {
48107       delete arg1;
48108     } catch (std::out_of_range& e) {
48109       {
48110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48111       };
48112     } catch (std::exception& e) {
48113       {
48114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48115       };
48116     } catch (Dali::DaliException e) {
48117       {
48118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48119       };
48120     } catch (...) {
48121       {
48122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48123       };
48124     }
48125   }
48126
48127 }
48128
48129
48130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48131   void * jresult ;
48132   Dali::CameraActor *arg1 = 0 ;
48133   Dali::CameraActor *result = 0 ;
48134
48135   arg1 = (Dali::CameraActor *)jarg1;
48136   if (!arg1) {
48137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48138     return 0;
48139   }
48140   {
48141     try {
48142       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48150       };
48151     } catch (Dali::DaliException e) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48158       };
48159     }
48160   }
48161
48162   jresult = (void *)result;
48163   return jresult;
48164 }
48165
48166
48167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48168   void * jresult ;
48169   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48170   Dali::CameraActor *arg2 = 0 ;
48171   Dali::CameraActor *result = 0 ;
48172
48173   arg1 = (Dali::CameraActor *)jarg1;
48174   arg2 = (Dali::CameraActor *)jarg2;
48175   if (!arg2) {
48176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48177     return 0;
48178   }
48179   {
48180     try {
48181       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48182     } catch (std::out_of_range& e) {
48183       {
48184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48185       };
48186     } catch (std::exception& e) {
48187       {
48188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48189       };
48190     } catch (Dali::DaliException e) {
48191       {
48192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48193       };
48194     } catch (...) {
48195       {
48196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48197       };
48198     }
48199   }
48200
48201   jresult = (void *)result;
48202   return jresult;
48203 }
48204
48205
48206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48207   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48208   Dali::Camera::Type arg2 ;
48209
48210   arg1 = (Dali::CameraActor *)jarg1;
48211   arg2 = (Dali::Camera::Type)jarg2;
48212   {
48213     try {
48214       (arg1)->SetType(arg2);
48215     } catch (std::out_of_range& e) {
48216       {
48217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48218       };
48219     } catch (std::exception& e) {
48220       {
48221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48222       };
48223     } catch (Dali::DaliException e) {
48224       {
48225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48226       };
48227     } catch (...) {
48228       {
48229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48230       };
48231     }
48232   }
48233
48234 }
48235
48236
48237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48238   int jresult ;
48239   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48240   Dali::Camera::Type result;
48241
48242   arg1 = (Dali::CameraActor *)jarg1;
48243   {
48244     try {
48245       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48246     } catch (std::out_of_range& e) {
48247       {
48248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48249       };
48250     } catch (std::exception& e) {
48251       {
48252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48253       };
48254     } catch (Dali::DaliException e) {
48255       {
48256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48257       };
48258     } catch (...) {
48259       {
48260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48261       };
48262     }
48263   }
48264
48265   jresult = (int)result;
48266   return jresult;
48267 }
48268
48269
48270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48271   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48272   Dali::Camera::ProjectionMode arg2 ;
48273
48274   arg1 = (Dali::CameraActor *)jarg1;
48275   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48276   {
48277     try {
48278       (arg1)->SetProjectionMode(arg2);
48279     } catch (std::out_of_range& e) {
48280       {
48281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48282       };
48283     } catch (std::exception& e) {
48284       {
48285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48286       };
48287     } catch (Dali::DaliException e) {
48288       {
48289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48290       };
48291     } catch (...) {
48292       {
48293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48294       };
48295     }
48296   }
48297
48298 }
48299
48300
48301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48302   int jresult ;
48303   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48304   Dali::Camera::ProjectionMode result;
48305
48306   arg1 = (Dali::CameraActor *)jarg1;
48307   {
48308     try {
48309       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48310     } catch (std::out_of_range& e) {
48311       {
48312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48313       };
48314     } catch (std::exception& e) {
48315       {
48316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48317       };
48318     } catch (Dali::DaliException e) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48321       };
48322     } catch (...) {
48323       {
48324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48325       };
48326     }
48327   }
48328
48329   jresult = (int)result;
48330   return jresult;
48331 }
48332
48333
48334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48336   float arg2 ;
48337
48338   arg1 = (Dali::CameraActor *)jarg1;
48339   arg2 = (float)jarg2;
48340   {
48341     try {
48342       (arg1)->SetFieldOfView(arg2);
48343     } catch (std::out_of_range& e) {
48344       {
48345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48346       };
48347     } catch (std::exception& e) {
48348       {
48349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48350       };
48351     } catch (Dali::DaliException e) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48354       };
48355     } catch (...) {
48356       {
48357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48358       };
48359     }
48360   }
48361
48362 }
48363
48364
48365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48366   float jresult ;
48367   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48368   float result;
48369
48370   arg1 = (Dali::CameraActor *)jarg1;
48371   {
48372     try {
48373       result = (float)(arg1)->GetFieldOfView();
48374     } catch (std::out_of_range& e) {
48375       {
48376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (std::exception& e) {
48379       {
48380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48381       };
48382     } catch (Dali::DaliException e) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48385       };
48386     } catch (...) {
48387       {
48388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48389       };
48390     }
48391   }
48392
48393   jresult = result;
48394   return jresult;
48395 }
48396
48397
48398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48399   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48400   float arg2 ;
48401
48402   arg1 = (Dali::CameraActor *)jarg1;
48403   arg2 = (float)jarg2;
48404   {
48405     try {
48406       (arg1)->SetAspectRatio(arg2);
48407     } catch (std::out_of_range& e) {
48408       {
48409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48410       };
48411     } catch (std::exception& e) {
48412       {
48413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48414       };
48415     } catch (Dali::DaliException e) {
48416       {
48417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48418       };
48419     } catch (...) {
48420       {
48421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48422       };
48423     }
48424   }
48425
48426 }
48427
48428
48429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48430   float jresult ;
48431   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48432   float result;
48433
48434   arg1 = (Dali::CameraActor *)jarg1;
48435   {
48436     try {
48437       result = (float)(arg1)->GetAspectRatio();
48438     } catch (std::out_of_range& e) {
48439       {
48440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48441       };
48442     } catch (std::exception& e) {
48443       {
48444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48445       };
48446     } catch (Dali::DaliException e) {
48447       {
48448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48449       };
48450     } catch (...) {
48451       {
48452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48453       };
48454     }
48455   }
48456
48457   jresult = result;
48458   return jresult;
48459 }
48460
48461
48462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48463   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48464   float arg2 ;
48465
48466   arg1 = (Dali::CameraActor *)jarg1;
48467   arg2 = (float)jarg2;
48468   {
48469     try {
48470       (arg1)->SetNearClippingPlane(arg2);
48471     } catch (std::out_of_range& e) {
48472       {
48473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48474       };
48475     } catch (std::exception& e) {
48476       {
48477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48478       };
48479     } catch (Dali::DaliException e) {
48480       {
48481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48482       };
48483     } catch (...) {
48484       {
48485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48486       };
48487     }
48488   }
48489
48490 }
48491
48492
48493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48494   float jresult ;
48495   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48496   float result;
48497
48498   arg1 = (Dali::CameraActor *)jarg1;
48499   {
48500     try {
48501       result = (float)(arg1)->GetNearClippingPlane();
48502     } catch (std::out_of_range& e) {
48503       {
48504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48505       };
48506     } catch (std::exception& e) {
48507       {
48508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48509       };
48510     } catch (Dali::DaliException e) {
48511       {
48512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48513       };
48514     } catch (...) {
48515       {
48516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48517       };
48518     }
48519   }
48520
48521   jresult = result;
48522   return jresult;
48523 }
48524
48525
48526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48527   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48528   float arg2 ;
48529
48530   arg1 = (Dali::CameraActor *)jarg1;
48531   arg2 = (float)jarg2;
48532   {
48533     try {
48534       (arg1)->SetFarClippingPlane(arg2);
48535     } catch (std::out_of_range& e) {
48536       {
48537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48538       };
48539     } catch (std::exception& e) {
48540       {
48541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48542       };
48543     } catch (Dali::DaliException e) {
48544       {
48545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48546       };
48547     } catch (...) {
48548       {
48549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48550       };
48551     }
48552   }
48553
48554 }
48555
48556
48557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48558   float jresult ;
48559   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48560   float result;
48561
48562   arg1 = (Dali::CameraActor *)jarg1;
48563   {
48564     try {
48565       result = (float)(arg1)->GetFarClippingPlane();
48566     } catch (std::out_of_range& e) {
48567       {
48568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48569       };
48570     } catch (std::exception& e) {
48571       {
48572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48573       };
48574     } catch (Dali::DaliException e) {
48575       {
48576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48577       };
48578     } catch (...) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48581       };
48582     }
48583   }
48584
48585   jresult = result;
48586   return jresult;
48587 }
48588
48589
48590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48591   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48592   Dali::Vector3 *arg2 = 0 ;
48593
48594   arg1 = (Dali::CameraActor *)jarg1;
48595   arg2 = (Dali::Vector3 *)jarg2;
48596   if (!arg2) {
48597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48598     return ;
48599   }
48600   {
48601     try {
48602       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48603     } catch (std::out_of_range& e) {
48604       {
48605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (std::exception& e) {
48608       {
48609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48610       };
48611     } catch (Dali::DaliException e) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48614       };
48615     } catch (...) {
48616       {
48617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48618       };
48619     }
48620   }
48621
48622 }
48623
48624
48625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48626   void * jresult ;
48627   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48628   Dali::Vector3 result;
48629
48630   arg1 = (Dali::CameraActor *)jarg1;
48631   {
48632     try {
48633       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48634     } catch (std::out_of_range& e) {
48635       {
48636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48637       };
48638     } catch (std::exception& e) {
48639       {
48640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48641       };
48642     } catch (Dali::DaliException e) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48645       };
48646     } catch (...) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48649       };
48650     }
48651   }
48652
48653   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48654   return jresult;
48655 }
48656
48657
48658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48659   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48660   bool arg2 ;
48661
48662   arg1 = (Dali::CameraActor *)jarg1;
48663   arg2 = jarg2 ? true : false;
48664   {
48665     try {
48666       (arg1)->SetInvertYAxis(arg2);
48667     } catch (std::out_of_range& e) {
48668       {
48669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48670       };
48671     } catch (std::exception& e) {
48672       {
48673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48674       };
48675     } catch (Dali::DaliException e) {
48676       {
48677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48678       };
48679     } catch (...) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48682       };
48683     }
48684   }
48685
48686 }
48687
48688
48689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48690   unsigned int jresult ;
48691   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48692   bool result;
48693
48694   arg1 = (Dali::CameraActor *)jarg1;
48695   {
48696     try {
48697       result = (bool)(arg1)->GetInvertYAxis();
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48705       };
48706     } catch (Dali::DaliException e) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48709       };
48710     } catch (...) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48713       };
48714     }
48715   }
48716
48717   jresult = result;
48718   return jresult;
48719 }
48720
48721
48722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48723   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48724   Dali::Size *arg2 = 0 ;
48725
48726   arg1 = (Dali::CameraActor *)jarg1;
48727   arg2 = (Dali::Size *)jarg2;
48728   if (!arg2) {
48729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48730     return ;
48731   }
48732   {
48733     try {
48734       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48742       };
48743     } catch (Dali::DaliException e) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48746       };
48747     } catch (...) {
48748       {
48749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48750       };
48751     }
48752   }
48753
48754 }
48755
48756
48757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48758   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48759   Dali::Size *arg2 = 0 ;
48760
48761   arg1 = (Dali::CameraActor *)jarg1;
48762   arg2 = (Dali::Size *)jarg2;
48763   if (!arg2) {
48764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48765     return ;
48766   }
48767   {
48768     try {
48769       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48770     } catch (std::out_of_range& e) {
48771       {
48772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48773       };
48774     } catch (std::exception& e) {
48775       {
48776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48777       };
48778     } catch (Dali::DaliException e) {
48779       {
48780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48781       };
48782     } catch (...) {
48783       {
48784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48785       };
48786     }
48787   }
48788
48789 }
48790
48791
48792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48793   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48794   float arg2 ;
48795   float arg3 ;
48796   float arg4 ;
48797   float arg5 ;
48798   float arg6 ;
48799   float arg7 ;
48800
48801   arg1 = (Dali::CameraActor *)jarg1;
48802   arg2 = (float)jarg2;
48803   arg3 = (float)jarg3;
48804   arg4 = (float)jarg4;
48805   arg5 = (float)jarg5;
48806   arg6 = (float)jarg6;
48807   arg7 = (float)jarg7;
48808   {
48809     try {
48810       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48811     } catch (std::out_of_range& e) {
48812       {
48813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48814       };
48815     } catch (std::exception& e) {
48816       {
48817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48818       };
48819     } catch (Dali::DaliException e) {
48820       {
48821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48822       };
48823     } catch (...) {
48824       {
48825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48826       };
48827     }
48828   }
48829
48830 }
48831
48832
48833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48834   void * jresult ;
48835   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48836
48837   {
48838     try {
48839       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48840     } catch (std::out_of_range& e) {
48841       {
48842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48843       };
48844     } catch (std::exception& e) {
48845       {
48846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48847       };
48848     } catch (Dali::DaliException e) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48851       };
48852     } catch (...) {
48853       {
48854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48855       };
48856     }
48857   }
48858
48859   jresult = (void *)result;
48860   return jresult;
48861 }
48862
48863
48864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
48865   void * jresult ;
48866   std::string arg1 ;
48867   Dali::Property::Value arg2 ;
48868   Dali::Property::Value *argp2 ;
48869   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48870
48871   if (!jarg1) {
48872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48873     return 0;
48874   }
48875   (&arg1)->assign(jarg1);
48876   argp2 = (Dali::Property::Value *)jarg2;
48877   if (!argp2) {
48878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
48879     return 0;
48880   }
48881   arg2 = *argp2;
48882   {
48883     try {
48884       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
48885     } catch (std::out_of_range& e) {
48886       {
48887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48888       };
48889     } catch (std::exception& e) {
48890       {
48891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48892       };
48893     } catch (Dali::DaliException e) {
48894       {
48895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48896       };
48897     } catch (...) {
48898       {
48899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48900       };
48901     }
48902   }
48903
48904   jresult = (void *)result;
48905   return jresult;
48906 }
48907
48908
48909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
48910   void * jresult ;
48911   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
48912   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48913
48914   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48915   if (!arg1) {
48916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
48917     return 0;
48918   }
48919   {
48920     try {
48921       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);
48922     } catch (std::out_of_range& e) {
48923       {
48924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48925       };
48926     } catch (std::exception& e) {
48927       {
48928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48929       };
48930     } catch (Dali::DaliException e) {
48931       {
48932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48933       };
48934     } catch (...) {
48935       {
48936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48937       };
48938     }
48939   }
48940
48941   jresult = (void *)result;
48942   return jresult;
48943 }
48944
48945
48946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
48947   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48948   std::string *arg2 = 0 ;
48949
48950   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48951   if (!jarg2) {
48952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
48953     return ;
48954   }
48955   std::string arg2_str(jarg2);
48956   arg2 = &arg2_str;
48957   if (arg1) (arg1)->first = *arg2;
48958
48959   //argout typemap for const std::string&
48960
48961 }
48962
48963
48964 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
48965   char * jresult ;
48966   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48967   std::string *result = 0 ;
48968
48969   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48970   result = (std::string *) & ((arg1)->first);
48971   jresult = SWIG_csharp_string_callback(result->c_str());
48972   return jresult;
48973 }
48974
48975
48976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
48977   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48978   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
48979
48980   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48981   arg2 = (Dali::Property::Value *)jarg2;
48982   if (arg1) (arg1)->second = *arg2;
48983 }
48984
48985
48986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
48987   void * jresult ;
48988   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
48989   Dali::Property::Value *result = 0 ;
48990
48991   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
48992   result = (Dali::Property::Value *)& ((arg1)->second);
48993   jresult = (void *)result;
48994   return jresult;
48995 }
48996
48997
48998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
48999   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49000
49001   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49002   {
49003     try {
49004       delete arg1;
49005     } catch (std::out_of_range& e) {
49006       {
49007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49008       };
49009     } catch (std::exception& e) {
49010       {
49011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49012       };
49013     } catch (Dali::DaliException e) {
49014       {
49015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49016       };
49017     } catch (...) {
49018       {
49019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49020       };
49021     }
49022   }
49023
49024 }
49025
49026
49027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49028   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49029
49030   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49031   {
49032     try {
49033       (arg1)->clear();
49034     } catch (std::out_of_range& e) {
49035       {
49036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49037       };
49038     } catch (std::exception& e) {
49039       {
49040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49041       };
49042     } catch (Dali::DaliException e) {
49043       {
49044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49045       };
49046     } catch (...) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49049       };
49050     }
49051   }
49052
49053 }
49054
49055
49056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49057   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49058   Dali::TouchPoint *arg2 = 0 ;
49059
49060   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49061   arg2 = (Dali::TouchPoint *)jarg2;
49062   if (!arg2) {
49063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49064     return ;
49065   }
49066   {
49067     try {
49068       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49069     } catch (std::out_of_range& e) {
49070       {
49071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49072       };
49073     } catch (std::exception& e) {
49074       {
49075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49076       };
49077     } catch (Dali::DaliException e) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49080       };
49081     } catch (...) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49084       };
49085     }
49086   }
49087
49088 }
49089
49090
49091 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49092   unsigned long jresult ;
49093   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49094   std::vector< Dali::TouchPoint >::size_type result;
49095
49096   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49097   {
49098     try {
49099       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49100     } catch (std::out_of_range& e) {
49101       {
49102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49103       };
49104     } catch (std::exception& e) {
49105       {
49106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49107       };
49108     } catch (Dali::DaliException e) {
49109       {
49110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49111       };
49112     } catch (...) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49115       };
49116     }
49117   }
49118
49119   jresult = (unsigned long)result;
49120   return jresult;
49121 }
49122
49123
49124 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49125   unsigned long jresult ;
49126   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49127   std::vector< Dali::TouchPoint >::size_type result;
49128
49129   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49130   {
49131     try {
49132       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49133     } catch (std::out_of_range& e) {
49134       {
49135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49136       };
49137     } catch (std::exception& e) {
49138       {
49139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49140       };
49141     } catch (Dali::DaliException e) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49144       };
49145     } catch (...) {
49146       {
49147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49148       };
49149     }
49150   }
49151
49152   jresult = (unsigned long)result;
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49158   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49159   std::vector< Dali::TouchPoint >::size_type arg2 ;
49160
49161   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49162   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49163   {
49164     try {
49165       (arg1)->reserve(arg2);
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49173       };
49174     } catch (Dali::DaliException e) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49177       };
49178     } catch (...) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49181       };
49182     }
49183   }
49184
49185 }
49186
49187
49188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49189   void * jresult ;
49190   std::vector< Dali::TouchPoint > *result = 0 ;
49191
49192   {
49193     try {
49194       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49195     } catch (std::out_of_range& e) {
49196       {
49197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49198       };
49199     } catch (std::exception& e) {
49200       {
49201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49202       };
49203     } catch (Dali::DaliException e) {
49204       {
49205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49206       };
49207     } catch (...) {
49208       {
49209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49210       };
49211     }
49212   }
49213
49214   jresult = (void *)result;
49215   return jresult;
49216 }
49217
49218
49219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49220   void * jresult ;
49221   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49222   std::vector< Dali::TouchPoint > *result = 0 ;
49223
49224   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49225   if (!arg1) {
49226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49227     return 0;
49228   }
49229   {
49230     try {
49231       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (Dali::DaliException e) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49247       };
49248     }
49249   }
49250
49251   jresult = (void *)result;
49252   return jresult;
49253 }
49254
49255
49256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49257   void * jresult ;
49258   int arg1 ;
49259   std::vector< Dali::TouchPoint > *result = 0 ;
49260
49261   arg1 = (int)jarg1;
49262   {
49263     try {
49264       try {
49265         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49266       }
49267       catch(std::out_of_range &_e) {
49268         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49269         return 0;
49270       }
49271
49272     } catch (std::out_of_range& e) {
49273       {
49274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49275       };
49276     } catch (std::exception& e) {
49277       {
49278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49279       };
49280     } catch (Dali::DaliException e) {
49281       {
49282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49283       };
49284     } catch (...) {
49285       {
49286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49287       };
49288     }
49289   }
49290
49291   jresult = (void *)result;
49292   return jresult;
49293 }
49294
49295
49296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49297   void * jresult ;
49298   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49299   int arg2 ;
49300   SwigValueWrapper< Dali::TouchPoint > result;
49301
49302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49303   arg2 = (int)jarg2;
49304   {
49305     try {
49306       try {
49307         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49308       }
49309       catch(std::out_of_range &_e) {
49310         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49311         return 0;
49312       }
49313
49314     } catch (std::out_of_range& e) {
49315       {
49316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49317       };
49318     } catch (std::exception& e) {
49319       {
49320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49321       };
49322     } catch (Dali::DaliException e) {
49323       {
49324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49325       };
49326     } catch (...) {
49327       {
49328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49329       };
49330     }
49331   }
49332
49333   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49334   return jresult;
49335 }
49336
49337
49338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49339   void * jresult ;
49340   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49341   int arg2 ;
49342   Dali::TouchPoint *result = 0 ;
49343
49344   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49345   arg2 = (int)jarg2;
49346   {
49347     try {
49348       try {
49349         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49350       }
49351       catch(std::out_of_range &_e) {
49352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49353         return 0;
49354       }
49355
49356     } catch (std::out_of_range& e) {
49357       {
49358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49359       };
49360     } catch (std::exception& e) {
49361       {
49362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (Dali::DaliException e) {
49365       {
49366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49367       };
49368     } catch (...) {
49369       {
49370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49371       };
49372     }
49373   }
49374
49375   jresult = (void *)result;
49376   return jresult;
49377 }
49378
49379
49380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49381   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49382   int arg2 ;
49383   Dali::TouchPoint *arg3 = 0 ;
49384
49385   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49386   arg2 = (int)jarg2;
49387   arg3 = (Dali::TouchPoint *)jarg3;
49388   if (!arg3) {
49389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49390     return ;
49391   }
49392   {
49393     try {
49394       try {
49395         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49396       }
49397       catch(std::out_of_range &_e) {
49398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49399         return ;
49400       }
49401
49402     } catch (std::out_of_range& e) {
49403       {
49404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49405       };
49406     } catch (std::exception& e) {
49407       {
49408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49409       };
49410     } catch (Dali::DaliException e) {
49411       {
49412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49413       };
49414     } catch (...) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49417       };
49418     }
49419   }
49420
49421 }
49422
49423
49424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49425   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49426   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49427
49428   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49429   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49430   if (!arg2) {
49431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49432     return ;
49433   }
49434   {
49435     try {
49436       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49437     } catch (std::out_of_range& e) {
49438       {
49439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49440       };
49441     } catch (std::exception& e) {
49442       {
49443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49444       };
49445     } catch (Dali::DaliException e) {
49446       {
49447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49448       };
49449     } catch (...) {
49450       {
49451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49452       };
49453     }
49454   }
49455
49456 }
49457
49458
49459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49460   void * jresult ;
49461   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49462   int arg2 ;
49463   int arg3 ;
49464   std::vector< Dali::TouchPoint > *result = 0 ;
49465
49466   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49467   arg2 = (int)jarg2;
49468   arg3 = (int)jarg3;
49469   {
49470     try {
49471       try {
49472         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49473       }
49474       catch(std::out_of_range &_e) {
49475         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49476         return 0;
49477       }
49478       catch(std::invalid_argument &_e) {
49479         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49480         return 0;
49481       }
49482
49483     } catch (std::out_of_range& e) {
49484       {
49485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49486       };
49487     } catch (std::exception& e) {
49488       {
49489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49490       };
49491     } catch (Dali::DaliException e) {
49492       {
49493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49494       };
49495     } catch (...) {
49496       {
49497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49498       };
49499     }
49500   }
49501
49502   jresult = (void *)result;
49503   return jresult;
49504 }
49505
49506
49507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49508   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49509   int arg2 ;
49510   Dali::TouchPoint *arg3 = 0 ;
49511
49512   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49513   arg2 = (int)jarg2;
49514   arg3 = (Dali::TouchPoint *)jarg3;
49515   if (!arg3) {
49516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49517     return ;
49518   }
49519   {
49520     try {
49521       try {
49522         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49523       }
49524       catch(std::out_of_range &_e) {
49525         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49526         return ;
49527       }
49528
49529     } catch (std::out_of_range& e) {
49530       {
49531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49532       };
49533     } catch (std::exception& e) {
49534       {
49535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49536       };
49537     } catch (Dali::DaliException e) {
49538       {
49539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49540       };
49541     } catch (...) {
49542       {
49543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49544       };
49545     }
49546   }
49547
49548 }
49549
49550
49551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49552   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49553   int arg2 ;
49554   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49555
49556   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49557   arg2 = (int)jarg2;
49558   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49559   if (!arg3) {
49560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49561     return ;
49562   }
49563   {
49564     try {
49565       try {
49566         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49567       }
49568       catch(std::out_of_range &_e) {
49569         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49570         return ;
49571       }
49572
49573     } catch (std::out_of_range& e) {
49574       {
49575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49576       };
49577     } catch (std::exception& e) {
49578       {
49579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (Dali::DaliException e) {
49582       {
49583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49584       };
49585     } catch (...) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49588       };
49589     }
49590   }
49591
49592 }
49593
49594
49595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49596   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49597   int arg2 ;
49598
49599   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49600   arg2 = (int)jarg2;
49601   {
49602     try {
49603       try {
49604         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49605       }
49606       catch(std::out_of_range &_e) {
49607         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49608         return ;
49609       }
49610
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49618       };
49619     } catch (Dali::DaliException e) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49622       };
49623     } catch (...) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49626       };
49627     }
49628   }
49629
49630 }
49631
49632
49633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49634   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49635   int arg2 ;
49636   int arg3 ;
49637
49638   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49639   arg2 = (int)jarg2;
49640   arg3 = (int)jarg3;
49641   {
49642     try {
49643       try {
49644         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49645       }
49646       catch(std::out_of_range &_e) {
49647         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49648         return ;
49649       }
49650       catch(std::invalid_argument &_e) {
49651         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49652         return ;
49653       }
49654
49655     } catch (std::out_of_range& e) {
49656       {
49657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49658       };
49659     } catch (std::exception& e) {
49660       {
49661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49662       };
49663     } catch (Dali::DaliException e) {
49664       {
49665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49666       };
49667     } catch (...) {
49668       {
49669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49670       };
49671     }
49672   }
49673
49674 }
49675
49676
49677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49678   void * jresult ;
49679   Dali::TouchPoint *arg1 = 0 ;
49680   int arg2 ;
49681   std::vector< Dali::TouchPoint > *result = 0 ;
49682
49683   arg1 = (Dali::TouchPoint *)jarg1;
49684   if (!arg1) {
49685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49686     return 0;
49687   }
49688   arg2 = (int)jarg2;
49689   {
49690     try {
49691       try {
49692         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49693       }
49694       catch(std::out_of_range &_e) {
49695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49696         return 0;
49697       }
49698
49699     } catch (std::out_of_range& e) {
49700       {
49701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49702       };
49703     } catch (std::exception& e) {
49704       {
49705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49706       };
49707     } catch (Dali::DaliException e) {
49708       {
49709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49710       };
49711     } catch (...) {
49712       {
49713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49714       };
49715     }
49716   }
49717
49718   jresult = (void *)result;
49719   return jresult;
49720 }
49721
49722
49723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49724   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49725
49726   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49727   {
49728     try {
49729       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49730     } catch (std::out_of_range& e) {
49731       {
49732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49733       };
49734     } catch (std::exception& e) {
49735       {
49736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49737       };
49738     } catch (Dali::DaliException e) {
49739       {
49740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49741       };
49742     } catch (...) {
49743       {
49744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49745       };
49746     }
49747   }
49748
49749 }
49750
49751
49752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49753   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49754   int arg2 ;
49755   int arg3 ;
49756
49757   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49758   arg2 = (int)jarg2;
49759   arg3 = (int)jarg3;
49760   {
49761     try {
49762       try {
49763         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49764       }
49765       catch(std::out_of_range &_e) {
49766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49767         return ;
49768       }
49769       catch(std::invalid_argument &_e) {
49770         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49771         return ;
49772       }
49773
49774     } catch (std::out_of_range& e) {
49775       {
49776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49777       };
49778     } catch (std::exception& e) {
49779       {
49780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49781       };
49782     } catch (Dali::DaliException e) {
49783       {
49784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49785       };
49786     } catch (...) {
49787       {
49788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49789       };
49790     }
49791   }
49792
49793 }
49794
49795
49796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49797   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49798   int arg2 ;
49799   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49800
49801   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49802   arg2 = (int)jarg2;
49803   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49804   if (!arg3) {
49805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49806     return ;
49807   }
49808   {
49809     try {
49810       try {
49811         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49812       }
49813       catch(std::out_of_range &_e) {
49814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49815         return ;
49816       }
49817
49818     } catch (std::out_of_range& e) {
49819       {
49820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49821       };
49822     } catch (std::exception& e) {
49823       {
49824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49825       };
49826     } catch (Dali::DaliException e) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49829       };
49830     } catch (...) {
49831       {
49832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49833       };
49834     }
49835   }
49836
49837 }
49838
49839
49840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49841   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49842
49843   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49844   {
49845     try {
49846       delete arg1;
49847     } catch (std::out_of_range& e) {
49848       {
49849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (std::exception& e) {
49852       {
49853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49854       };
49855     } catch (Dali::DaliException e) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49858       };
49859     } catch (...) {
49860       {
49861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49862       };
49863     }
49864   }
49865
49866 }
49867
49868
49869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
49870   void * jresult ;
49871   Dali::Rect< int > *result = 0 ;
49872
49873   {
49874     try {
49875       result = (Dali::Rect< int > *)new Dali::Rect< int >();
49876     } catch (std::out_of_range& e) {
49877       {
49878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49879       };
49880     } catch (std::exception& e) {
49881       {
49882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49883       };
49884     } catch (Dali::DaliException e) {
49885       {
49886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49887       };
49888     } catch (...) {
49889       {
49890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49891       };
49892     }
49893   }
49894
49895   jresult = (void *)result;
49896   return jresult;
49897 }
49898
49899
49900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
49901   void * jresult ;
49902   int arg1 ;
49903   int arg2 ;
49904   int arg3 ;
49905   int arg4 ;
49906   Dali::Rect< int > *result = 0 ;
49907
49908   arg1 = (int)jarg1;
49909   arg2 = (int)jarg2;
49910   arg3 = (int)jarg3;
49911   arg4 = (int)jarg4;
49912   {
49913     try {
49914       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
49915     } catch (std::out_of_range& e) {
49916       {
49917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49918       };
49919     } catch (std::exception& e) {
49920       {
49921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49922       };
49923     } catch (Dali::DaliException e) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49926       };
49927     } catch (...) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49930       };
49931     }
49932   }
49933
49934   jresult = (void *)result;
49935   return jresult;
49936 }
49937
49938
49939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
49940   void * jresult ;
49941   Dali::Rect< int > *arg1 = 0 ;
49942   Dali::Rect< int > *result = 0 ;
49943
49944   arg1 = (Dali::Rect< int > *)jarg1;
49945   if (!arg1) {
49946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49947     return 0;
49948   }
49949   {
49950     try {
49951       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
49952     } catch (std::out_of_range& e) {
49953       {
49954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49955       };
49956     } catch (std::exception& e) {
49957       {
49958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49959       };
49960     } catch (Dali::DaliException e) {
49961       {
49962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49963       };
49964     } catch (...) {
49965       {
49966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49967       };
49968     }
49969   }
49970
49971   jresult = (void *)result;
49972   return jresult;
49973 }
49974
49975
49976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
49977   void * jresult ;
49978   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49979   Dali::Rect< int > *arg2 = 0 ;
49980   Dali::Rect< int > *result = 0 ;
49981
49982   arg1 = (Dali::Rect< int > *)jarg1;
49983   arg2 = (Dali::Rect< int > *)jarg2;
49984   if (!arg2) {
49985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49986     return 0;
49987   }
49988   {
49989     try {
49990       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
49991     } catch (std::out_of_range& e) {
49992       {
49993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49994       };
49995     } catch (std::exception& e) {
49996       {
49997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49998       };
49999     } catch (Dali::DaliException e) {
50000       {
50001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50002       };
50003     } catch (...) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50006       };
50007     }
50008   }
50009
50010   jresult = (void *)result;
50011   return jresult;
50012 }
50013
50014
50015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50016   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50017   int arg2 ;
50018   int arg3 ;
50019   int arg4 ;
50020   int arg5 ;
50021
50022   arg1 = (Dali::Rect< int > *)jarg1;
50023   arg2 = (int)jarg2;
50024   arg3 = (int)jarg3;
50025   arg4 = (int)jarg4;
50026   arg5 = (int)jarg5;
50027   {
50028     try {
50029       (arg1)->Set(arg2,arg3,arg4,arg5);
50030     } catch (std::out_of_range& e) {
50031       {
50032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50033       };
50034     } catch (std::exception& e) {
50035       {
50036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50037       };
50038     } catch (Dali::DaliException e) {
50039       {
50040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50041       };
50042     } catch (...) {
50043       {
50044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50045       };
50046     }
50047   }
50048
50049 }
50050
50051
50052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50053   unsigned int jresult ;
50054   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50055   bool result;
50056
50057   arg1 = (Dali::Rect< int > *)jarg1;
50058   {
50059     try {
50060       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50061     } catch (std::out_of_range& e) {
50062       {
50063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50064       };
50065     } catch (std::exception& e) {
50066       {
50067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50068       };
50069     } catch (Dali::DaliException e) {
50070       {
50071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50072       };
50073     } catch (...) {
50074       {
50075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50076       };
50077     }
50078   }
50079
50080   jresult = result;
50081   return jresult;
50082 }
50083
50084
50085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50086   int jresult ;
50087   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50088   int result;
50089
50090   arg1 = (Dali::Rect< int > *)jarg1;
50091   {
50092     try {
50093       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50094     } catch (std::out_of_range& e) {
50095       {
50096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50097       };
50098     } catch (std::exception& e) {
50099       {
50100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50101       };
50102     } catch (Dali::DaliException e) {
50103       {
50104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50105       };
50106     } catch (...) {
50107       {
50108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50109       };
50110     }
50111   }
50112
50113   jresult = result;
50114   return jresult;
50115 }
50116
50117
50118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50119   int jresult ;
50120   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50121   int result;
50122
50123   arg1 = (Dali::Rect< int > *)jarg1;
50124   {
50125     try {
50126       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50127     } catch (std::out_of_range& e) {
50128       {
50129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (std::exception& e) {
50132       {
50133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50134       };
50135     } catch (Dali::DaliException e) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50138       };
50139     } catch (...) {
50140       {
50141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50142       };
50143     }
50144   }
50145
50146   jresult = result;
50147   return jresult;
50148 }
50149
50150
50151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50152   int jresult ;
50153   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50154   int result;
50155
50156   arg1 = (Dali::Rect< int > *)jarg1;
50157   {
50158     try {
50159       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50160     } catch (std::out_of_range& e) {
50161       {
50162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50163       };
50164     } catch (std::exception& e) {
50165       {
50166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50167       };
50168     } catch (Dali::DaliException e) {
50169       {
50170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50171       };
50172     } catch (...) {
50173       {
50174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50175       };
50176     }
50177   }
50178
50179   jresult = result;
50180   return jresult;
50181 }
50182
50183
50184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50185   int jresult ;
50186   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50187   int result;
50188
50189   arg1 = (Dali::Rect< int > *)jarg1;
50190   {
50191     try {
50192       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50193     } catch (std::out_of_range& e) {
50194       {
50195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50196       };
50197     } catch (std::exception& e) {
50198       {
50199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50200       };
50201     } catch (Dali::DaliException e) {
50202       {
50203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50204       };
50205     } catch (...) {
50206       {
50207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50208       };
50209     }
50210   }
50211
50212   jresult = result;
50213   return jresult;
50214 }
50215
50216
50217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50218   int jresult ;
50219   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50220   int result;
50221
50222   arg1 = (Dali::Rect< int > *)jarg1;
50223   {
50224     try {
50225       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50226     } catch (std::out_of_range& e) {
50227       {
50228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50229       };
50230     } catch (std::exception& e) {
50231       {
50232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50233       };
50234     } catch (Dali::DaliException e) {
50235       {
50236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50237       };
50238     } catch (...) {
50239       {
50240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50241       };
50242     }
50243   }
50244
50245   jresult = result;
50246   return jresult;
50247 }
50248
50249
50250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50251   unsigned int jresult ;
50252   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50253   Dali::Rect< int > *arg2 = 0 ;
50254   bool result;
50255
50256   arg1 = (Dali::Rect< int > *)jarg1;
50257   arg2 = (Dali::Rect< int > *)jarg2;
50258   if (!arg2) {
50259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50260     return 0;
50261   }
50262   {
50263     try {
50264       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50265     } catch (std::out_of_range& e) {
50266       {
50267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50268       };
50269     } catch (std::exception& e) {
50270       {
50271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50272       };
50273     } catch (Dali::DaliException e) {
50274       {
50275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50276       };
50277     } catch (...) {
50278       {
50279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50280       };
50281     }
50282   }
50283
50284   jresult = result;
50285   return jresult;
50286 }
50287
50288
50289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50290   unsigned int jresult ;
50291   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50292   Dali::Rect< int > *arg2 = 0 ;
50293   bool result;
50294
50295   arg1 = (Dali::Rect< int > *)jarg1;
50296   arg2 = (Dali::Rect< int > *)jarg2;
50297   if (!arg2) {
50298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50299     return 0;
50300   }
50301   {
50302     try {
50303       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50304     } catch (std::out_of_range& e) {
50305       {
50306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50307       };
50308     } catch (std::exception& e) {
50309       {
50310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50311       };
50312     } catch (Dali::DaliException e) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50319       };
50320     }
50321   }
50322
50323   jresult = result;
50324   return jresult;
50325 }
50326
50327
50328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50329   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50330   int arg2 ;
50331
50332   arg1 = (Dali::Rect< int > *)jarg1;
50333   arg2 = (int)jarg2;
50334   if (arg1) (arg1)->x = arg2;
50335 }
50336
50337
50338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50339   int jresult ;
50340   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50341   int result;
50342
50343   arg1 = (Dali::Rect< int > *)jarg1;
50344   result = (int) ((arg1)->x);
50345   jresult = result;
50346   return jresult;
50347 }
50348
50349
50350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50351   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50352   int arg2 ;
50353
50354   arg1 = (Dali::Rect< int > *)jarg1;
50355   arg2 = (int)jarg2;
50356   if (arg1) (arg1)->left = arg2;
50357 }
50358
50359
50360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50361   int jresult ;
50362   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50363   int result;
50364
50365   arg1 = (Dali::Rect< int > *)jarg1;
50366   result = (int) ((arg1)->left);
50367   jresult = result;
50368   return jresult;
50369 }
50370
50371
50372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50373   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50374   int arg2 ;
50375
50376   arg1 = (Dali::Rect< int > *)jarg1;
50377   arg2 = (int)jarg2;
50378   if (arg1) (arg1)->y = arg2;
50379 }
50380
50381
50382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50383   int jresult ;
50384   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50385   int result;
50386
50387   arg1 = (Dali::Rect< int > *)jarg1;
50388   result = (int) ((arg1)->y);
50389   jresult = result;
50390   return jresult;
50391 }
50392
50393
50394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50395   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50396   int arg2 ;
50397
50398   arg1 = (Dali::Rect< int > *)jarg1;
50399   arg2 = (int)jarg2;
50400   if (arg1) (arg1)->right = arg2;
50401 }
50402
50403
50404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50405   int jresult ;
50406   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50407   int result;
50408
50409   arg1 = (Dali::Rect< int > *)jarg1;
50410   result = (int) ((arg1)->right);
50411   jresult = result;
50412   return jresult;
50413 }
50414
50415
50416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50417   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50418   int arg2 ;
50419
50420   arg1 = (Dali::Rect< int > *)jarg1;
50421   arg2 = (int)jarg2;
50422   if (arg1) (arg1)->width = arg2;
50423 }
50424
50425
50426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50427   int jresult ;
50428   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50429   int result;
50430
50431   arg1 = (Dali::Rect< int > *)jarg1;
50432   result = (int) ((arg1)->width);
50433   jresult = result;
50434   return jresult;
50435 }
50436
50437
50438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50439   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50440   int arg2 ;
50441
50442   arg1 = (Dali::Rect< int > *)jarg1;
50443   arg2 = (int)jarg2;
50444   if (arg1) (arg1)->bottom = arg2;
50445 }
50446
50447
50448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50449   int jresult ;
50450   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50451   int result;
50452
50453   arg1 = (Dali::Rect< int > *)jarg1;
50454   result = (int) ((arg1)->bottom);
50455   jresult = result;
50456   return jresult;
50457 }
50458
50459
50460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50461   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50462   int arg2 ;
50463
50464   arg1 = (Dali::Rect< int > *)jarg1;
50465   arg2 = (int)jarg2;
50466   if (arg1) (arg1)->height = arg2;
50467 }
50468
50469
50470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50471   int jresult ;
50472   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50473   int result;
50474
50475   arg1 = (Dali::Rect< int > *)jarg1;
50476   result = (int) ((arg1)->height);
50477   jresult = result;
50478   return jresult;
50479 }
50480
50481
50482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50483   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50484   int arg2 ;
50485
50486   arg1 = (Dali::Rect< int > *)jarg1;
50487   arg2 = (int)jarg2;
50488   if (arg1) (arg1)->top = arg2;
50489 }
50490
50491
50492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50493   int jresult ;
50494   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50495   int result;
50496
50497   arg1 = (Dali::Rect< int > *)jarg1;
50498   result = (int) ((arg1)->top);
50499   jresult = result;
50500   return jresult;
50501 }
50502
50503
50504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50505   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50506
50507   arg1 = (Dali::Rect< int > *)jarg1;
50508   {
50509     try {
50510       delete arg1;
50511     } catch (std::out_of_range& e) {
50512       {
50513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50514       };
50515     } catch (std::exception& e) {
50516       {
50517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50518       };
50519     } catch (Dali::DaliException e) {
50520       {
50521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50522       };
50523     } catch (...) {
50524       {
50525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50526       };
50527     }
50528   }
50529
50530 }
50531
50532
50533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50534   void * jresult ;
50535   Dali::Rect< float > *result = 0 ;
50536
50537   {
50538     try {
50539       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50540     } catch (std::out_of_range& e) {
50541       {
50542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50543       };
50544     } catch (std::exception& e) {
50545       {
50546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50547       };
50548     } catch (Dali::DaliException e) {
50549       {
50550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50551       };
50552     } catch (...) {
50553       {
50554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50555       };
50556     }
50557   }
50558
50559   jresult = (void *)result;
50560   return jresult;
50561 }
50562
50563
50564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50565   void * jresult ;
50566   float arg1 ;
50567   float arg2 ;
50568   float arg3 ;
50569   float arg4 ;
50570   Dali::Rect< float > *result = 0 ;
50571
50572   arg1 = (float)jarg1;
50573   arg2 = (float)jarg2;
50574   arg3 = (float)jarg4;
50575   arg4 = (float)jarg3;
50576   {
50577     try {
50578       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50579     } catch (std::out_of_range& e) {
50580       {
50581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50582       };
50583     } catch (std::exception& e) {
50584       {
50585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50586       };
50587     } catch (Dali::DaliException e) {
50588       {
50589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50590       };
50591     } catch (...) {
50592       {
50593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50594       };
50595     }
50596   }
50597
50598   jresult = (void *)result;
50599   return jresult;
50600 }
50601
50602
50603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50604   void * jresult ;
50605   Dali::Rect< float > *arg1 = 0 ;
50606   Dali::Rect< float > *result = 0 ;
50607
50608   arg1 = (Dali::Rect< float > *)jarg1;
50609   if (!arg1) {
50610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50611     return 0;
50612   }
50613   {
50614     try {
50615       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50616     } catch (std::out_of_range& e) {
50617       {
50618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50619       };
50620     } catch (std::exception& e) {
50621       {
50622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50623       };
50624     } catch (Dali::DaliException e) {
50625       {
50626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50627       };
50628     } catch (...) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50631       };
50632     }
50633   }
50634
50635   jresult = (void *)result;
50636   return jresult;
50637 }
50638
50639
50640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50641   void * jresult ;
50642   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50643   Dali::Rect< float > *arg2 = 0 ;
50644   Dali::Rect< float > *result = 0 ;
50645
50646   arg1 = (Dali::Rect< float > *)jarg1;
50647   arg2 = (Dali::Rect< float > *)jarg2;
50648   if (!arg2) {
50649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50650     return 0;
50651   }
50652   {
50653     try {
50654       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50662       };
50663     } catch (Dali::DaliException e) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50666       };
50667     } catch (...) {
50668       {
50669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50670       };
50671     }
50672   }
50673
50674   jresult = (void *)result;
50675   return jresult;
50676 }
50677
50678
50679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50680   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50681   float arg2 ;
50682   float arg3 ;
50683   float arg4 ;
50684   float arg5 ;
50685
50686   arg1 = (Dali::Rect< float > *)jarg1;
50687   arg2 = (float)jarg2;
50688   arg3 = (float)jarg3;
50689   arg4 = (float)jarg5;
50690   arg5 = (float)jarg4;
50691   {
50692     try {
50693       (arg1)->Set(arg2,arg3,arg4,arg5);
50694     } catch (std::out_of_range& e) {
50695       {
50696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50697       };
50698     } catch (std::exception& e) {
50699       {
50700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50701       };
50702     } catch (Dali::DaliException e) {
50703       {
50704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50705       };
50706     } catch (...) {
50707       {
50708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50709       };
50710     }
50711   }
50712
50713 }
50714
50715
50716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50717   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50718   float arg2 ;
50719
50720   arg1 = (Dali::Rect< float > *)jarg1;
50721   arg2 = (float)jarg2;
50722   if (arg1) (arg1)->left = arg2;
50723 }
50724
50725
50726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50727   float jresult ;
50728   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50729   float result;
50730
50731   arg1 = (Dali::Rect< float > *)jarg1;
50732   result = (float) ((arg1)->left);
50733   jresult = result;
50734   return jresult;
50735 }
50736
50737
50738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50739   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50740   float arg2 ;
50741
50742   arg1 = (Dali::Rect< float > *)jarg1;
50743   arg2 = (float)jarg2;
50744   if (arg1) (arg1)->left = arg2;
50745 }
50746
50747
50748 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50749   float jresult ;
50750   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50751   float result;
50752
50753   arg1 = (Dali::Rect< float > *)jarg1;
50754   result = (float) ((arg1)->left);
50755   jresult = result;
50756   return jresult;
50757 }
50758
50759
50760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50761   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50762   float arg2 ;
50763
50764   arg1 = (Dali::Rect< float > *)jarg1;
50765   arg2 = (float)jarg2;
50766   if (arg1) (arg1)->right = arg2;
50767 }
50768
50769
50770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50771   float jresult ;
50772   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50773   float result;
50774
50775   arg1 = (Dali::Rect< float > *)jarg1;
50776   result = (float) ((arg1)->right);
50777   jresult = result;
50778   return jresult;
50779 }
50780
50781
50782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50783   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50784   float arg2 ;
50785
50786   arg1 = (Dali::Rect< float > *)jarg1;
50787   arg2 = (float)jarg2;
50788   if (arg1) (arg1)->right = arg2;
50789 }
50790
50791
50792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50793   float jresult ;
50794   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50795   float result;
50796
50797   arg1 = (Dali::Rect< float > *)jarg1;
50798   result = (float) ((arg1)->right);
50799   jresult = result;
50800   return jresult;
50801 }
50802
50803
50804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50805   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50806   float arg2 ;
50807
50808   arg1 = (Dali::Rect< float > *)jarg1;
50809   arg2 = (float)jarg2;
50810   if (arg1) (arg1)->bottom = arg2;
50811 }
50812
50813
50814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50815   float jresult ;
50816   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50817   float result;
50818
50819   arg1 = (Dali::Rect< float > *)jarg1;
50820   result = (float) ((arg1)->bottom);
50821   jresult = result;
50822   return jresult;
50823 }
50824
50825
50826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50827   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50828   float arg2 ;
50829
50830   arg1 = (Dali::Rect< float > *)jarg1;
50831   arg2 = (float)jarg2;
50832   if (arg1) (arg1)->top = arg2;
50833 }
50834
50835
50836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50837   float jresult ;
50838   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50839   float result;
50840
50841   arg1 = (Dali::Rect< float > *)jarg1;
50842   result = (float) ((arg1)->top);
50843   jresult = result;
50844   return jresult;
50845 }
50846
50847
50848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50849   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50850
50851   arg1 = (Dali::Rect< float > *)jarg1;
50852   {
50853     try {
50854       delete arg1;
50855     } catch (std::out_of_range& e) {
50856       {
50857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50858       };
50859     } catch (std::exception& e) {
50860       {
50861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50862       };
50863     } catch (Dali::DaliException e) {
50864       {
50865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50866       };
50867     } catch (...) {
50868       {
50869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50870       };
50871     }
50872   }
50873
50874 }
50875
50876
50877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
50878   int jresult ;
50879   int result;
50880
50881   result = (int)Dali::Vector< int >::BaseType;
50882   jresult = (int)result;
50883   return jresult;
50884 }
50885
50886
50887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
50888   void * jresult ;
50889   Dali::Vector< int > *result = 0 ;
50890
50891   {
50892     try {
50893       result = (Dali::Vector< int > *)new Dali::Vector< int >();
50894     } catch (std::out_of_range& e) {
50895       {
50896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50897       };
50898     } catch (std::exception& e) {
50899       {
50900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50901       };
50902     } catch (Dali::DaliException e) {
50903       {
50904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50905       };
50906     } catch (...) {
50907       {
50908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50909       };
50910     }
50911   }
50912
50913   jresult = (void *)result;
50914   return jresult;
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
50919   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50920
50921   arg1 = (Dali::Vector< int > *)jarg1;
50922   {
50923     try {
50924       delete arg1;
50925     } catch (std::out_of_range& e) {
50926       {
50927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50928       };
50929     } catch (std::exception& e) {
50930       {
50931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50932       };
50933     } catch (Dali::DaliException e) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50936       };
50937     } catch (...) {
50938       {
50939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50940       };
50941     }
50942   }
50943
50944 }
50945
50946
50947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
50948   void * jresult ;
50949   Dali::Vector< int > *arg1 = 0 ;
50950   Dali::Vector< int > *result = 0 ;
50951
50952   arg1 = (Dali::Vector< int > *)jarg1;
50953   if (!arg1) {
50954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50955     return 0;
50956   }
50957   {
50958     try {
50959       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
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_VectorInteger_Assign(void * jarg1, void * jarg2) {
50985   void * jresult ;
50986   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50987   Dali::Vector< int > *arg2 = 0 ;
50988   Dali::Vector< int > *result = 0 ;
50989
50990   arg1 = (Dali::Vector< int > *)jarg1;
50991   arg2 = (Dali::Vector< int > *)jarg2;
50992   if (!arg2) {
50993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
50994     return 0;
50995   }
50996   {
50997     try {
50998       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
50999     } catch (std::out_of_range& e) {
51000       {
51001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51002       };
51003     } catch (std::exception& e) {
51004       {
51005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51006       };
51007     } catch (Dali::DaliException e) {
51008       {
51009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51014       };
51015     }
51016   }
51017
51018   jresult = (void *)result;
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51024   void * jresult ;
51025   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51026   Dali::Vector< int >::Iterator result;
51027
51028   arg1 = (Dali::Vector< int > *)jarg1;
51029   {
51030     try {
51031       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51032     } catch (std::out_of_range& e) {
51033       {
51034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51035       };
51036     } catch (std::exception& e) {
51037       {
51038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51039       };
51040     } catch (Dali::DaliException e) {
51041       {
51042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51043       };
51044     } catch (...) {
51045       {
51046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51047       };
51048     }
51049   }
51050
51051   jresult = (void *)result;
51052   return jresult;
51053 }
51054
51055
51056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51057   void * jresult ;
51058   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51059   Dali::Vector< int >::Iterator result;
51060
51061   arg1 = (Dali::Vector< int > *)jarg1;
51062   {
51063     try {
51064       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51072       };
51073     } catch (Dali::DaliException e) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51076       };
51077     } catch (...) {
51078       {
51079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51080       };
51081     }
51082   }
51083
51084   jresult = (void *)result;
51085   return jresult;
51086 }
51087
51088
51089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51090   void * jresult ;
51091   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51092   Dali::Vector< int >::SizeType arg2 ;
51093   Dali::Vector< int >::ItemType *result = 0 ;
51094
51095   arg1 = (Dali::Vector< int > *)jarg1;
51096   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51097   {
51098     try {
51099       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51100     } catch (std::out_of_range& e) {
51101       {
51102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51103       };
51104     } catch (std::exception& e) {
51105       {
51106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51107       };
51108     } catch (Dali::DaliException e) {
51109       {
51110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51111       };
51112     } catch (...) {
51113       {
51114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51115       };
51116     }
51117   }
51118
51119   jresult = (void *)result;
51120   return jresult;
51121 }
51122
51123
51124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51125   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51126   Dali::Vector< int >::ItemType *arg2 = 0 ;
51127   Dali::Vector< int >::ItemType temp2 ;
51128
51129   arg1 = (Dali::Vector< int > *)jarg1;
51130   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51131   arg2 = &temp2;
51132   {
51133     try {
51134       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51135     } catch (std::out_of_range& e) {
51136       {
51137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51138       };
51139     } catch (std::exception& e) {
51140       {
51141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51142       };
51143     } catch (Dali::DaliException e) {
51144       {
51145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51146       };
51147     } catch (...) {
51148       {
51149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51150       };
51151     }
51152   }
51153
51154 }
51155
51156
51157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51158   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51159   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51160   Dali::Vector< int >::ItemType *arg3 = 0 ;
51161   Dali::Vector< int >::ItemType temp3 ;
51162
51163   arg1 = (Dali::Vector< int > *)jarg1;
51164   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51165   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51166   arg3 = &temp3;
51167   {
51168     try {
51169       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51170     } catch (std::out_of_range& e) {
51171       {
51172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51173       };
51174     } catch (std::exception& e) {
51175       {
51176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51177       };
51178     } catch (Dali::DaliException e) {
51179       {
51180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51181       };
51182     } catch (...) {
51183       {
51184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51185       };
51186     }
51187   }
51188
51189 }
51190
51191
51192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51193   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51194   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51195   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51196   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51197
51198   arg1 = (Dali::Vector< int > *)jarg1;
51199   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51200   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51201   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51202   {
51203     try {
51204       (arg1)->Insert(arg2,arg3,arg4);
51205     } catch (std::out_of_range& e) {
51206       {
51207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51208       };
51209     } catch (std::exception& e) {
51210       {
51211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51212       };
51213     } catch (Dali::DaliException e) {
51214       {
51215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51216       };
51217     } catch (...) {
51218       {
51219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51220       };
51221     }
51222   }
51223
51224 }
51225
51226
51227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51228   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51229   Dali::Vector< int >::SizeType arg2 ;
51230
51231   arg1 = (Dali::Vector< int > *)jarg1;
51232   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51233   {
51234     try {
51235       (arg1)->Reserve(arg2);
51236     } catch (std::out_of_range& e) {
51237       {
51238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51239       };
51240     } catch (std::exception& e) {
51241       {
51242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51243       };
51244     } catch (Dali::DaliException e) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51247       };
51248     } catch (...) {
51249       {
51250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51251       };
51252     }
51253   }
51254
51255 }
51256
51257
51258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51259   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51260   Dali::Vector< int >::SizeType arg2 ;
51261
51262   arg1 = (Dali::Vector< int > *)jarg1;
51263   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51264   {
51265     try {
51266       (arg1)->Resize(arg2);
51267     } catch (std::out_of_range& e) {
51268       {
51269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51270       };
51271     } catch (std::exception& e) {
51272       {
51273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51274       };
51275     } catch (Dali::DaliException e) {
51276       {
51277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51278       };
51279     } catch (...) {
51280       {
51281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51282       };
51283     }
51284   }
51285
51286 }
51287
51288
51289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51290   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51291   Dali::Vector< int >::SizeType arg2 ;
51292   Dali::Vector< int >::ItemType *arg3 = 0 ;
51293   Dali::Vector< int >::ItemType temp3 ;
51294
51295   arg1 = (Dali::Vector< int > *)jarg1;
51296   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51297   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51298   arg3 = &temp3;
51299   {
51300     try {
51301       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51302     } catch (std::out_of_range& e) {
51303       {
51304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51305       };
51306     } catch (std::exception& e) {
51307       {
51308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51309       };
51310     } catch (Dali::DaliException e) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51313       };
51314     } catch (...) {
51315       {
51316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51317       };
51318     }
51319   }
51320
51321 }
51322
51323
51324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51325   void * jresult ;
51326   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51327   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51328   Dali::Vector< int >::Iterator result;
51329
51330   arg1 = (Dali::Vector< int > *)jarg1;
51331   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51332   {
51333     try {
51334       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51335     } catch (std::out_of_range& e) {
51336       {
51337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51338       };
51339     } catch (std::exception& e) {
51340       {
51341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51342       };
51343     } catch (Dali::DaliException e) {
51344       {
51345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51346       };
51347     } catch (...) {
51348       {
51349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51350       };
51351     }
51352   }
51353
51354   jresult = (void *)result;
51355   return jresult;
51356 }
51357
51358
51359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51360   void * jresult ;
51361   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51362   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51363   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51364   Dali::Vector< int >::Iterator result;
51365
51366   arg1 = (Dali::Vector< int > *)jarg1;
51367   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51368   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51369   {
51370     try {
51371       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51372     } catch (std::out_of_range& e) {
51373       {
51374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51375       };
51376     } catch (std::exception& e) {
51377       {
51378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51379       };
51380     } catch (Dali::DaliException e) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51383       };
51384     } catch (...) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51387       };
51388     }
51389   }
51390
51391   jresult = (void *)result;
51392   return jresult;
51393 }
51394
51395
51396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51397   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51398   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51399
51400   arg1 = (Dali::Vector< int > *)jarg1;
51401   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51402   {
51403     try {
51404       (arg1)->Remove(arg2);
51405     } catch (std::out_of_range& e) {
51406       {
51407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51408       };
51409     } catch (std::exception& e) {
51410       {
51411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51412       };
51413     } catch (Dali::DaliException e) {
51414       {
51415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51416       };
51417     } catch (...) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51420       };
51421     }
51422   }
51423
51424 }
51425
51426
51427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51428   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51429   Dali::Vector< int > *arg2 = 0 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   arg2 = (Dali::Vector< int > *)jarg2;
51433   if (!arg2) {
51434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51435     return ;
51436   }
51437   {
51438     try {
51439       (arg1)->Swap(*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_Clear(void * jarg1) {
51463   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51464
51465   arg1 = (Dali::Vector< int > *)jarg1;
51466   {
51467     try {
51468       (arg1)->Clear();
51469     } catch (std::out_of_range& e) {
51470       {
51471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51472       };
51473     } catch (std::exception& e) {
51474       {
51475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (Dali::DaliException e) {
51478       {
51479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51480       };
51481     } catch (...) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51484       };
51485     }
51486   }
51487
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51493
51494   arg1 = (Dali::Vector< int > *)jarg1;
51495   {
51496     try {
51497       (arg1)->Release();
51498     } catch (std::out_of_range& e) {
51499       {
51500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (std::exception& e) {
51503       {
51504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51505       };
51506     } catch (Dali::DaliException e) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51509       };
51510     } catch (...) {
51511       {
51512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51513       };
51514     }
51515   }
51516
51517 }
51518
51519
51520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51521   int jresult ;
51522   int result;
51523
51524   result = (int)Dali::Vector< float >::BaseType;
51525   jresult = (int)result;
51526   return jresult;
51527 }
51528
51529
51530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51531   void * jresult ;
51532   Dali::Vector< float > *result = 0 ;
51533
51534   {
51535     try {
51536       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51537     } catch (std::out_of_range& e) {
51538       {
51539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51540       };
51541     } catch (std::exception& e) {
51542       {
51543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51544       };
51545     } catch (Dali::DaliException e) {
51546       {
51547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51548       };
51549     } catch (...) {
51550       {
51551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51552       };
51553     }
51554   }
51555
51556   jresult = (void *)result;
51557   return jresult;
51558 }
51559
51560
51561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51562   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51563
51564   arg1 = (Dali::Vector< float > *)jarg1;
51565   {
51566     try {
51567       delete arg1;
51568     } catch (std::out_of_range& e) {
51569       {
51570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51571       };
51572     } catch (std::exception& e) {
51573       {
51574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51575       };
51576     } catch (Dali::DaliException e) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51579       };
51580     } catch (...) {
51581       {
51582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51583       };
51584     }
51585   }
51586
51587 }
51588
51589
51590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51591   void * jresult ;
51592   Dali::Vector< float > *arg1 = 0 ;
51593   Dali::Vector< float > *result = 0 ;
51594
51595   arg1 = (Dali::Vector< float > *)jarg1;
51596   if (!arg1) {
51597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51598     return 0;
51599   }
51600   {
51601     try {
51602       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51603     } catch (std::out_of_range& e) {
51604       {
51605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51606       };
51607     } catch (std::exception& e) {
51608       {
51609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51610       };
51611     } catch (Dali::DaliException e) {
51612       {
51613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51614       };
51615     } catch (...) {
51616       {
51617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51618       };
51619     }
51620   }
51621
51622   jresult = (void *)result;
51623   return jresult;
51624 }
51625
51626
51627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51628   void * jresult ;
51629   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51630   Dali::Vector< float > *arg2 = 0 ;
51631   Dali::Vector< float > *result = 0 ;
51632
51633   arg1 = (Dali::Vector< float > *)jarg1;
51634   arg2 = (Dali::Vector< float > *)jarg2;
51635   if (!arg2) {
51636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51637     return 0;
51638   }
51639   {
51640     try {
51641       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51642     } catch (std::out_of_range& e) {
51643       {
51644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51645       };
51646     } catch (std::exception& e) {
51647       {
51648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51649       };
51650     } catch (Dali::DaliException e) {
51651       {
51652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51653       };
51654     } catch (...) {
51655       {
51656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51657       };
51658     }
51659   }
51660
51661   jresult = (void *)result;
51662   return jresult;
51663 }
51664
51665
51666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51667   void * jresult ;
51668   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51669   Dali::Vector< float >::Iterator result;
51670
51671   arg1 = (Dali::Vector< float > *)jarg1;
51672   {
51673     try {
51674       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51675     } catch (std::out_of_range& e) {
51676       {
51677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51678       };
51679     } catch (std::exception& e) {
51680       {
51681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51682       };
51683     } catch (Dali::DaliException e) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51686       };
51687     } catch (...) {
51688       {
51689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51690       };
51691     }
51692   }
51693
51694   jresult = (void *)result;
51695   return jresult;
51696 }
51697
51698
51699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51700   void * jresult ;
51701   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51702   Dali::Vector< float >::Iterator result;
51703
51704   arg1 = (Dali::Vector< float > *)jarg1;
51705   {
51706     try {
51707       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51708     } catch (std::out_of_range& e) {
51709       {
51710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51711       };
51712     } catch (std::exception& e) {
51713       {
51714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51715       };
51716     } catch (Dali::DaliException e) {
51717       {
51718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51719       };
51720     } catch (...) {
51721       {
51722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51723       };
51724     }
51725   }
51726
51727   jresult = (void *)result;
51728   return jresult;
51729 }
51730
51731
51732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51733   void * jresult ;
51734   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51735   Dali::Vector< float >::SizeType arg2 ;
51736   Dali::Vector< float >::ItemType *result = 0 ;
51737
51738   arg1 = (Dali::Vector< float > *)jarg1;
51739   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51740   {
51741     try {
51742       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51743     } catch (std::out_of_range& e) {
51744       {
51745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51746       };
51747     } catch (std::exception& e) {
51748       {
51749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51750       };
51751     } catch (Dali::DaliException e) {
51752       {
51753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51754       };
51755     } catch (...) {
51756       {
51757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51758       };
51759     }
51760   }
51761
51762   jresult = (void *)result;
51763   return jresult;
51764 }
51765
51766
51767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51768   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51769   Dali::Vector< float >::ItemType *arg2 = 0 ;
51770   Dali::Vector< float >::ItemType temp2 ;
51771
51772   arg1 = (Dali::Vector< float > *)jarg1;
51773   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51774   arg2 = &temp2;
51775   {
51776     try {
51777       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51785       };
51786     } catch (Dali::DaliException e) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51793       };
51794     }
51795   }
51796
51797 }
51798
51799
51800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51801   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51802   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51803   Dali::Vector< float >::ItemType *arg3 = 0 ;
51804   Dali::Vector< float >::ItemType temp3 ;
51805
51806   arg1 = (Dali::Vector< float > *)jarg1;
51807   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51808   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51809   arg3 = &temp3;
51810   {
51811     try {
51812       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51813     } catch (std::out_of_range& e) {
51814       {
51815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51816       };
51817     } catch (std::exception& e) {
51818       {
51819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51820       };
51821     } catch (Dali::DaliException e) {
51822       {
51823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51824       };
51825     } catch (...) {
51826       {
51827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51828       };
51829     }
51830   }
51831
51832 }
51833
51834
51835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51836   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51837   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51838   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51839   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51840
51841   arg1 = (Dali::Vector< float > *)jarg1;
51842   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51843   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51844   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51845   {
51846     try {
51847       (arg1)->Insert(arg2,arg3,arg4);
51848     } catch (std::out_of_range& e) {
51849       {
51850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51851       };
51852     } catch (std::exception& e) {
51853       {
51854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51855       };
51856     } catch (Dali::DaliException e) {
51857       {
51858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51859       };
51860     } catch (...) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51863       };
51864     }
51865   }
51866
51867 }
51868
51869
51870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
51871   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51872   Dali::Vector< float >::SizeType arg2 ;
51873
51874   arg1 = (Dali::Vector< float > *)jarg1;
51875   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51876   {
51877     try {
51878       (arg1)->Reserve(arg2);
51879     } catch (std::out_of_range& e) {
51880       {
51881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51882       };
51883     } catch (std::exception& e) {
51884       {
51885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51886       };
51887     } catch (Dali::DaliException e) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51890       };
51891     } catch (...) {
51892       {
51893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51894       };
51895     }
51896   }
51897
51898 }
51899
51900 //// ========================= end of part 2 =============================
51901
51902 //// ========================== start part 3 ===============================
51903
51904
51905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51906   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51907   Dali::Vector< float >::SizeType arg2 ;
51908
51909   arg1 = (Dali::Vector< float > *)jarg1;
51910   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51911   {
51912     try {
51913       (arg1)->Resize(arg2);
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51921       };
51922     } catch (Dali::DaliException e) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51925       };
51926     } catch (...) {
51927       {
51928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51929       };
51930     }
51931   }
51932
51933 }
51934
51935
51936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
51937   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51938   Dali::Vector< float >::SizeType arg2 ;
51939   Dali::Vector< float >::ItemType *arg3 = 0 ;
51940   Dali::Vector< float >::ItemType temp3 ;
51941
51942   arg1 = (Dali::Vector< float > *)jarg1;
51943   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51944   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51945   arg3 = &temp3;
51946   {
51947     try {
51948       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51949     } catch (std::out_of_range& e) {
51950       {
51951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51952       };
51953     } catch (std::exception& e) {
51954       {
51955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (Dali::DaliException e) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51960       };
51961     } catch (...) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51964       };
51965     }
51966   }
51967
51968 }
51969
51970
51971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
51972   void * jresult ;
51973   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51974   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51975   Dali::Vector< float >::Iterator result;
51976
51977   arg1 = (Dali::Vector< float > *)jarg1;
51978   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51979   {
51980     try {
51981       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
51982     } catch (std::out_of_range& e) {
51983       {
51984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51985       };
51986     } catch (std::exception& e) {
51987       {
51988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51989       };
51990     } catch (Dali::DaliException e) {
51991       {
51992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51993       };
51994     } catch (...) {
51995       {
51996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51997       };
51998     }
51999   }
52000
52001   jresult = (void *)result;
52002   return jresult;
52003 }
52004
52005
52006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52007   void * jresult ;
52008   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52009   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52010   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52011   Dali::Vector< float >::Iterator result;
52012
52013   arg1 = (Dali::Vector< float > *)jarg1;
52014   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52015   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52016   {
52017     try {
52018       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52019     } catch (std::out_of_range& e) {
52020       {
52021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52022       };
52023     } catch (std::exception& e) {
52024       {
52025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52026       };
52027     } catch (Dali::DaliException e) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52030       };
52031     } catch (...) {
52032       {
52033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52034       };
52035     }
52036   }
52037
52038   jresult = (void *)result;
52039   return jresult;
52040 }
52041
52042
52043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52044   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52045   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52046
52047   arg1 = (Dali::Vector< float > *)jarg1;
52048   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52049   {
52050     try {
52051       (arg1)->Remove(arg2);
52052     } catch (std::out_of_range& e) {
52053       {
52054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52055       };
52056     } catch (std::exception& e) {
52057       {
52058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52059       };
52060     } catch (Dali::DaliException e) {
52061       {
52062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52063       };
52064     } catch (...) {
52065       {
52066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52067       };
52068     }
52069   }
52070
52071 }
52072
52073
52074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52075   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52076   Dali::Vector< float > *arg2 = 0 ;
52077
52078   arg1 = (Dali::Vector< float > *)jarg1;
52079   arg2 = (Dali::Vector< float > *)jarg2;
52080   if (!arg2) {
52081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52082     return ;
52083   }
52084   {
52085     try {
52086       (arg1)->Swap(*arg2);
52087     } catch (std::out_of_range& e) {
52088       {
52089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52090       };
52091     } catch (std::exception& e) {
52092       {
52093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52094       };
52095     } catch (Dali::DaliException e) {
52096       {
52097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52098       };
52099     } catch (...) {
52100       {
52101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52102       };
52103     }
52104   }
52105
52106 }
52107
52108
52109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52110   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52111
52112   arg1 = (Dali::Vector< float > *)jarg1;
52113   {
52114     try {
52115       (arg1)->Clear();
52116     } catch (std::out_of_range& e) {
52117       {
52118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52119       };
52120     } catch (std::exception& e) {
52121       {
52122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52123       };
52124     } catch (Dali::DaliException e) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52127       };
52128     } catch (...) {
52129       {
52130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52131       };
52132     }
52133   }
52134
52135 }
52136
52137
52138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52139   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52140
52141   arg1 = (Dali::Vector< float > *)jarg1;
52142   {
52143     try {
52144       (arg1)->Release();
52145     } catch (std::out_of_range& e) {
52146       {
52147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52148       };
52149     } catch (std::exception& e) {
52150       {
52151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52152       };
52153     } catch (Dali::DaliException e) {
52154       {
52155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52156       };
52157     } catch (...) {
52158       {
52159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52160       };
52161     }
52162   }
52163
52164 }
52165
52166
52167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52168   int jresult ;
52169   int result;
52170
52171   result = (int)Dali::Vector< unsigned char >::BaseType;
52172   jresult = (int)result;
52173   return jresult;
52174 }
52175
52176
52177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52178   void * jresult ;
52179   Dali::Vector< unsigned char > *result = 0 ;
52180
52181   {
52182     try {
52183       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52184     } catch (std::out_of_range& e) {
52185       {
52186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52187       };
52188     } catch (std::exception& e) {
52189       {
52190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52191       };
52192     } catch (Dali::DaliException e) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52195       };
52196     } catch (...) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52199       };
52200     }
52201   }
52202
52203   jresult = (void *)result;
52204   return jresult;
52205 }
52206
52207
52208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52209   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52210
52211   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52212   {
52213     try {
52214       delete arg1;
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (Dali::DaliException e) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52226       };
52227     } catch (...) {
52228       {
52229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52230       };
52231     }
52232   }
52233
52234 }
52235
52236
52237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52238   void * jresult ;
52239   Dali::Vector< unsigned char > *arg1 = 0 ;
52240   Dali::Vector< unsigned char > *result = 0 ;
52241
52242   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52243   if (!arg1) {
52244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52245     return 0;
52246   }
52247   {
52248     try {
52249       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52250     } catch (std::out_of_range& e) {
52251       {
52252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (std::exception& e) {
52255       {
52256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52257       };
52258     } catch (Dali::DaliException e) {
52259       {
52260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52261       };
52262     } catch (...) {
52263       {
52264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52265       };
52266     }
52267   }
52268
52269   jresult = (void *)result;
52270   return jresult;
52271 }
52272
52273
52274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52275   void * jresult ;
52276   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52277   Dali::Vector< unsigned char > *arg2 = 0 ;
52278   Dali::Vector< unsigned char > *result = 0 ;
52279
52280   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52281   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52282   if (!arg2) {
52283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52284     return 0;
52285   }
52286   {
52287     try {
52288       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52289     } catch (std::out_of_range& e) {
52290       {
52291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52292       };
52293     } catch (std::exception& e) {
52294       {
52295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52296       };
52297     } catch (Dali::DaliException e) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52300       };
52301     } catch (...) {
52302       {
52303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52304       };
52305     }
52306   }
52307
52308   jresult = (void *)result;
52309   return jresult;
52310 }
52311
52312
52313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52314   void * jresult ;
52315   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52316   Dali::Vector< unsigned char >::Iterator result;
52317
52318   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52319   {
52320     try {
52321       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52329       };
52330     } catch (Dali::DaliException e) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52333       };
52334     } catch (...) {
52335       {
52336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52337       };
52338     }
52339   }
52340
52341   jresult = (void *)result;
52342   return jresult;
52343 }
52344
52345
52346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52347   void * jresult ;
52348   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52349   Dali::Vector< unsigned char >::Iterator result;
52350
52351   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52352   {
52353     try {
52354       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52355     } catch (std::out_of_range& e) {
52356       {
52357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52358       };
52359     } catch (std::exception& e) {
52360       {
52361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52362       };
52363     } catch (Dali::DaliException e) {
52364       {
52365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52366       };
52367     } catch (...) {
52368       {
52369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52370       };
52371     }
52372   }
52373
52374   jresult = (void *)result;
52375   return jresult;
52376 }
52377
52378
52379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52380   void * jresult ;
52381   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52382   Dali::Vector< unsigned char >::SizeType arg2 ;
52383   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52384
52385   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52386   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52387   {
52388     try {
52389       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52390     } catch (std::out_of_range& e) {
52391       {
52392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52393       };
52394     } catch (std::exception& e) {
52395       {
52396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52397       };
52398     } catch (Dali::DaliException e) {
52399       {
52400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52401       };
52402     } catch (...) {
52403       {
52404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52405       };
52406     }
52407   }
52408
52409   jresult = (void *)result;
52410   return jresult;
52411 }
52412
52413
52414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52415   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52416   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52417   Dali::Vector< unsigned char >::ItemType temp2 ;
52418
52419   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52420   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52421   arg2 = &temp2;
52422   {
52423     try {
52424       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52425     } catch (std::out_of_range& e) {
52426       {
52427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52428       };
52429     } catch (std::exception& e) {
52430       {
52431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52432       };
52433     } catch (Dali::DaliException e) {
52434       {
52435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52436       };
52437     } catch (...) {
52438       {
52439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52440       };
52441     }
52442   }
52443
52444 }
52445
52446
52447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52448   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52449   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52450   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52451   Dali::Vector< unsigned char >::ItemType temp3 ;
52452
52453   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52454   arg2 = jarg2;
52455   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52456   arg3 = &temp3;
52457   {
52458     try {
52459       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52460     } catch (std::out_of_range& e) {
52461       {
52462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52463       };
52464     } catch (std::exception& e) {
52465       {
52466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52467       };
52468     } catch (Dali::DaliException e) {
52469       {
52470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52471       };
52472     } catch (...) {
52473       {
52474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52475       };
52476     }
52477   }
52478
52479
52480
52481 }
52482
52483
52484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52485   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52486   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52487   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52488   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52489
52490   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52491   arg2 = jarg2;
52492   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52493   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52494   {
52495     try {
52496       (arg1)->Insert(arg2,arg3,arg4);
52497     } catch (std::out_of_range& e) {
52498       {
52499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52500       };
52501     } catch (std::exception& e) {
52502       {
52503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52504       };
52505     } catch (Dali::DaliException e) {
52506       {
52507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52508       };
52509     } catch (...) {
52510       {
52511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52512       };
52513     }
52514   }
52515
52516
52517
52518 }
52519
52520
52521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52522   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52523   Dali::Vector< unsigned char >::SizeType arg2 ;
52524
52525   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52526   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52527   {
52528     try {
52529       (arg1)->Reserve(arg2);
52530     } catch (std::out_of_range& e) {
52531       {
52532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52533       };
52534     } catch (std::exception& e) {
52535       {
52536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52537       };
52538     } catch (Dali::DaliException e) {
52539       {
52540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52541       };
52542     } catch (...) {
52543       {
52544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52545       };
52546     }
52547   }
52548
52549 }
52550
52551
52552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52553   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52554   Dali::Vector< unsigned char >::SizeType arg2 ;
52555
52556   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52557   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52558   {
52559     try {
52560       (arg1)->Resize(arg2);
52561     } catch (std::out_of_range& e) {
52562       {
52563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52564       };
52565     } catch (std::exception& e) {
52566       {
52567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52568       };
52569     } catch (Dali::DaliException e) {
52570       {
52571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52572       };
52573     } catch (...) {
52574       {
52575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52576       };
52577     }
52578   }
52579
52580 }
52581
52582
52583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52584   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52585   Dali::Vector< unsigned char >::SizeType arg2 ;
52586   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52587   Dali::Vector< unsigned char >::ItemType temp3 ;
52588
52589   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52590   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52591   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52592   arg3 = &temp3;
52593   {
52594     try {
52595       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52596     } catch (std::out_of_range& e) {
52597       {
52598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52599       };
52600     } catch (std::exception& e) {
52601       {
52602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52603       };
52604     } catch (Dali::DaliException e) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52607       };
52608     } catch (...) {
52609       {
52610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52611       };
52612     }
52613   }
52614
52615 }
52616
52617
52618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52619   void * jresult ;
52620   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52621   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52622   Dali::Vector< unsigned char >::Iterator result;
52623
52624   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52625   arg2 = jarg2;
52626   {
52627     try {
52628       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52629     } catch (std::out_of_range& e) {
52630       {
52631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52632       };
52633     } catch (std::exception& e) {
52634       {
52635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52636       };
52637     } catch (Dali::DaliException e) {
52638       {
52639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52640       };
52641     } catch (...) {
52642       {
52643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52644       };
52645     }
52646   }
52647
52648   jresult = (void *)result;
52649
52650
52651   return jresult;
52652 }
52653
52654
52655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52656   void * jresult ;
52657   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52658   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52659   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52660   Dali::Vector< unsigned char >::Iterator result;
52661
52662   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52663   arg2 = jarg2;
52664   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52665   {
52666     try {
52667       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52668     } catch (std::out_of_range& e) {
52669       {
52670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52671       };
52672     } catch (std::exception& e) {
52673       {
52674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52675       };
52676     } catch (Dali::DaliException e) {
52677       {
52678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52679       };
52680     } catch (...) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52683       };
52684     }
52685   }
52686
52687   jresult = (void *)result;
52688
52689
52690   return jresult;
52691 }
52692
52693
52694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52695   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52696   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52697
52698   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52699   arg2 = jarg2;
52700   {
52701     try {
52702       (arg1)->Remove(arg2);
52703     } catch (std::out_of_range& e) {
52704       {
52705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52706       };
52707     } catch (std::exception& e) {
52708       {
52709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52710       };
52711     } catch (Dali::DaliException e) {
52712       {
52713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52714       };
52715     } catch (...) {
52716       {
52717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52718       };
52719     }
52720   }
52721
52722
52723
52724 }
52725
52726
52727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52728   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52729   Dali::Vector< unsigned char > *arg2 = 0 ;
52730
52731   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52732   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52733   if (!arg2) {
52734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52735     return ;
52736   }
52737   {
52738     try {
52739       (arg1)->Swap(*arg2);
52740     } catch (std::out_of_range& e) {
52741       {
52742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52743       };
52744     } catch (std::exception& e) {
52745       {
52746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52747       };
52748     } catch (Dali::DaliException e) {
52749       {
52750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52751       };
52752     } catch (...) {
52753       {
52754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52755       };
52756     }
52757   }
52758
52759 }
52760
52761
52762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52763   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52764
52765   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52766   {
52767     try {
52768       (arg1)->Clear();
52769     } catch (std::out_of_range& e) {
52770       {
52771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52772       };
52773     } catch (std::exception& e) {
52774       {
52775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52776       };
52777     } catch (Dali::DaliException e) {
52778       {
52779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52780       };
52781     } catch (...) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52784       };
52785     }
52786   }
52787
52788 }
52789
52790
52791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52792   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52793
52794   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52795   {
52796     try {
52797       (arg1)->Release();
52798     } catch (std::out_of_range& e) {
52799       {
52800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52801       };
52802     } catch (std::exception& e) {
52803       {
52804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52805       };
52806     } catch (Dali::DaliException e) {
52807       {
52808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52809       };
52810     } catch (...) {
52811       {
52812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52813       };
52814     }
52815   }
52816
52817 }
52818
52819
52820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52821   int jresult ;
52822   int result;
52823
52824   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52825   jresult = (int)result;
52826   return jresult;
52827 }
52828
52829
52830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52831   void * jresult ;
52832   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52833
52834   {
52835     try {
52836       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52837     } catch (std::out_of_range& e) {
52838       {
52839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52840       };
52841     } catch (std::exception& e) {
52842       {
52843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52844       };
52845     } catch (Dali::DaliException e) {
52846       {
52847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52848       };
52849     } catch (...) {
52850       {
52851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52852       };
52853     }
52854   }
52855
52856   jresult = (void *)result;
52857   return jresult;
52858 }
52859
52860
52861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52862   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52863
52864   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52865   {
52866     try {
52867       delete arg1;
52868     } catch (std::out_of_range& e) {
52869       {
52870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52871       };
52872     } catch (std::exception& e) {
52873       {
52874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52875       };
52876     } catch (Dali::DaliException e) {
52877       {
52878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52879       };
52880     } catch (...) {
52881       {
52882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52883       };
52884     }
52885   }
52886
52887 }
52888
52889
52890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
52891   void * jresult ;
52892   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
52893   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52894
52895   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52896   if (!arg1) {
52897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52898     return 0;
52899   }
52900   {
52901     try {
52902       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
52903     } catch (std::out_of_range& e) {
52904       {
52905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52906       };
52907     } catch (std::exception& e) {
52908       {
52909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52910       };
52911     } catch (Dali::DaliException e) {
52912       {
52913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52914       };
52915     } catch (...) {
52916       {
52917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52918       };
52919     }
52920   }
52921
52922   jresult = (void *)result;
52923   return jresult;
52924 }
52925
52926
52927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
52928   void * jresult ;
52929   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52930   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52931   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52932
52933   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52934   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52935   if (!arg2) {
52936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
52937     return 0;
52938   }
52939   {
52940     try {
52941       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52949       };
52950     } catch (Dali::DaliException e) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52953       };
52954     } catch (...) {
52955       {
52956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52957       };
52958     }
52959   }
52960
52961   jresult = (void *)result;
52962   return jresult;
52963 }
52964
52965
52966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
52967   void * jresult ;
52968   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52969   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52970
52971   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52972   {
52973     try {
52974       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
52975     } catch (std::out_of_range& e) {
52976       {
52977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (std::exception& e) {
52980       {
52981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52982       };
52983     } catch (Dali::DaliException e) {
52984       {
52985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52986       };
52987     } catch (...) {
52988       {
52989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52990       };
52991     }
52992   }
52993
52994   jresult = (void *)result;
52995   return jresult;
52996 }
52997
52998
52999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53000   void * jresult ;
53001   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53002   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53003
53004   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53005   {
53006     try {
53007       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53008     } catch (std::out_of_range& e) {
53009       {
53010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53011       };
53012     } catch (std::exception& e) {
53013       {
53014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53015       };
53016     } catch (Dali::DaliException e) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53019       };
53020     } catch (...) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53023       };
53024     }
53025   }
53026
53027   jresult = (void *)result;
53028   return jresult;
53029 }
53030
53031
53032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53033   void * jresult ;
53034   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53035   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53036   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53037
53038   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53039   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53040   {
53041     try {
53042       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53043     } catch (std::out_of_range& e) {
53044       {
53045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53046       };
53047     } catch (std::exception& e) {
53048       {
53049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53050       };
53051     } catch (Dali::DaliException e) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53054       };
53055     } catch (...) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53058       };
53059     }
53060   }
53061
53062   jresult = (void *)result;
53063   return jresult;
53064 }
53065
53066
53067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53068   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53069   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53070
53071   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53072   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53073   if (!arg2) {
53074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53075     return ;
53076   }
53077   {
53078     try {
53079       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53080     } catch (std::out_of_range& e) {
53081       {
53082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53083       };
53084     } catch (std::exception& e) {
53085       {
53086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53087       };
53088     } catch (Dali::DaliException e) {
53089       {
53090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53091       };
53092     } catch (...) {
53093       {
53094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53095       };
53096     }
53097   }
53098
53099 }
53100
53101
53102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53103   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53104   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53105   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53106
53107   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53108   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53109   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53110   if (!arg3) {
53111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53112     return ;
53113   }
53114   {
53115     try {
53116       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53117     } catch (std::out_of_range& e) {
53118       {
53119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53120       };
53121     } catch (std::exception& e) {
53122       {
53123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53124       };
53125     } catch (Dali::DaliException e) {
53126       {
53127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53128       };
53129     } catch (...) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53132       };
53133     }
53134   }
53135
53136 }
53137
53138
53139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53140   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53141   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53142   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53143   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53144
53145   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53146   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53147   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53148   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53149   {
53150     try {
53151       (arg1)->Insert(arg2,arg3,arg4);
53152     } catch (std::out_of_range& e) {
53153       {
53154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53155       };
53156     } catch (std::exception& e) {
53157       {
53158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53159       };
53160     } catch (Dali::DaliException e) {
53161       {
53162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53163       };
53164     } catch (...) {
53165       {
53166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53167       };
53168     }
53169   }
53170
53171 }
53172
53173
53174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53175   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53176   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53177
53178   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53179   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53180   {
53181     try {
53182       (arg1)->Reserve(arg2);
53183     } catch (std::out_of_range& e) {
53184       {
53185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53186       };
53187     } catch (std::exception& e) {
53188       {
53189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53190       };
53191     } catch (Dali::DaliException e) {
53192       {
53193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53194       };
53195     } catch (...) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53198       };
53199     }
53200   }
53201
53202 }
53203
53204
53205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53206   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53207   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53208
53209   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53210   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53211   {
53212     try {
53213       (arg1)->Resize(arg2);
53214     } catch (std::out_of_range& e) {
53215       {
53216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53217       };
53218     } catch (std::exception& e) {
53219       {
53220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53221       };
53222     } catch (Dali::DaliException e) {
53223       {
53224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53225       };
53226     } catch (...) {
53227       {
53228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53229       };
53230     }
53231   }
53232
53233 }
53234
53235
53236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53237   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53238   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53239   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53240
53241   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53242   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53243   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53244   if (!arg3) {
53245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53246     return ;
53247   }
53248   {
53249     try {
53250       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53251     } catch (std::out_of_range& e) {
53252       {
53253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53254       };
53255     } catch (std::exception& e) {
53256       {
53257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53258       };
53259     } catch (Dali::DaliException e) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53262       };
53263     } catch (...) {
53264       {
53265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53266       };
53267     }
53268   }
53269
53270 }
53271
53272
53273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53274   void * jresult ;
53275   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53276   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53277   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53278
53279   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53280   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53281   {
53282     try {
53283       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53284     } catch (std::out_of_range& e) {
53285       {
53286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53287       };
53288     } catch (std::exception& e) {
53289       {
53290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53291       };
53292     } catch (Dali::DaliException e) {
53293       {
53294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53295       };
53296     } catch (...) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53299       };
53300     }
53301   }
53302
53303   jresult = (void *)result;
53304   return jresult;
53305 }
53306
53307
53308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53309   void * jresult ;
53310   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53311   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53312   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53313   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53314
53315   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53316   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53317   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53318   {
53319     try {
53320       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53321     } catch (std::out_of_range& e) {
53322       {
53323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53324       };
53325     } catch (std::exception& e) {
53326       {
53327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53328       };
53329     } catch (Dali::DaliException e) {
53330       {
53331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53332       };
53333     } catch (...) {
53334       {
53335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53336       };
53337     }
53338   }
53339
53340   jresult = (void *)result;
53341   return jresult;
53342 }
53343
53344
53345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53346   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53347   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53348
53349   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53350   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53351   {
53352     try {
53353       (arg1)->Remove(arg2);
53354     } catch (std::out_of_range& e) {
53355       {
53356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53357       };
53358     } catch (std::exception& e) {
53359       {
53360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53361       };
53362     } catch (Dali::DaliException e) {
53363       {
53364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53365       };
53366     } catch (...) {
53367       {
53368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53369       };
53370     }
53371   }
53372
53373 }
53374
53375
53376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53377   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53378   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53379
53380   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53381   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53382   if (!arg2) {
53383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53384     return ;
53385   }
53386   {
53387     try {
53388       (arg1)->Swap(*arg2);
53389     } catch (std::out_of_range& e) {
53390       {
53391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53392       };
53393     } catch (std::exception& e) {
53394       {
53395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53396       };
53397     } catch (Dali::DaliException e) {
53398       {
53399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53400       };
53401     } catch (...) {
53402       {
53403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53404       };
53405     }
53406   }
53407
53408 }
53409
53410
53411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53412   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53413
53414   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53415   {
53416     try {
53417       (arg1)->Clear();
53418     } catch (std::out_of_range& e) {
53419       {
53420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53421       };
53422     } catch (std::exception& e) {
53423       {
53424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53425       };
53426     } catch (Dali::DaliException e) {
53427       {
53428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53429       };
53430     } catch (...) {
53431       {
53432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53433       };
53434     }
53435   }
53436
53437 }
53438
53439
53440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53441   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53442
53443   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53444   {
53445     try {
53446       (arg1)->Release();
53447     } catch (std::out_of_range& e) {
53448       {
53449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53450       };
53451     } catch (std::exception& e) {
53452       {
53453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53454       };
53455     } catch (Dali::DaliException e) {
53456       {
53457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53462       };
53463     }
53464   }
53465
53466 }
53467
53468
53469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53470   void * jresult ;
53471   Dali::Signal< void () > *result = 0 ;
53472
53473   {
53474     try {
53475       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53476     } catch (std::out_of_range& e) {
53477       {
53478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53479       };
53480     } catch (std::exception& e) {
53481       {
53482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53483       };
53484     } catch (Dali::DaliException e) {
53485       {
53486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53487       };
53488     } catch (...) {
53489       {
53490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53491       };
53492     }
53493   }
53494
53495   jresult = (void *)result;
53496   return jresult;
53497 }
53498
53499
53500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53501   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53502
53503   arg1 = (Dali::Signal< void () > *)jarg1;
53504   {
53505     try {
53506       delete arg1;
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53514       };
53515     } catch (Dali::DaliException e) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53518       };
53519     } catch (...) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53522       };
53523     }
53524   }
53525
53526 }
53527
53528
53529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53530   unsigned int jresult ;
53531   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53532   bool result;
53533
53534   arg1 = (Dali::Signal< void () > *)jarg1;
53535   {
53536     try {
53537       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53538     } catch (std::out_of_range& e) {
53539       {
53540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53541       };
53542     } catch (std::exception& e) {
53543       {
53544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53545       };
53546     } catch (Dali::DaliException e) {
53547       {
53548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53549       };
53550     } catch (...) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53553       };
53554     }
53555   }
53556
53557   jresult = result;
53558   return jresult;
53559 }
53560
53561
53562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53563   unsigned long jresult ;
53564   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53565   std::size_t result;
53566
53567   arg1 = (Dali::Signal< void () > *)jarg1;
53568   {
53569     try {
53570       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53571     } catch (std::out_of_range& e) {
53572       {
53573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53574       };
53575     } catch (std::exception& e) {
53576       {
53577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53578       };
53579     } catch (Dali::DaliException e) {
53580       {
53581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53582       };
53583     } catch (...) {
53584       {
53585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53586       };
53587     }
53588   }
53589
53590   jresult = (unsigned long)result;
53591   return jresult;
53592 }
53593
53594
53595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53596   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53597   void (*arg2)() = (void (*)()) 0 ;
53598
53599   arg1 = (Dali::Signal< void () > *)jarg1;
53600   arg2 = (void (*)())jarg2;
53601   {
53602     try {
53603       (arg1)->Connect(arg2);
53604     } catch (std::out_of_range& e) {
53605       {
53606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53607       };
53608     } catch (std::exception& e) {
53609       {
53610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53611       };
53612     } catch (Dali::DaliException e) {
53613       {
53614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53615       };
53616     } catch (...) {
53617       {
53618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53619       };
53620     }
53621   }
53622
53623 }
53624
53625
53626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53627   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53628   void (*arg2)() = (void (*)()) 0 ;
53629
53630   arg1 = (Dali::Signal< void () > *)jarg1;
53631   arg2 = (void (*)())jarg2;
53632   {
53633     try {
53634       (arg1)->Disconnect(arg2);
53635     } catch (std::out_of_range& e) {
53636       {
53637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (std::exception& e) {
53640       {
53641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53642       };
53643     } catch (Dali::DaliException e) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53646       };
53647     } catch (...) {
53648       {
53649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53650       };
53651     }
53652   }
53653
53654 }
53655
53656
53657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53658   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53659   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53660   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53661
53662   arg1 = (Dali::Signal< void () > *)jarg1;
53663   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53664   arg3 = (Dali::FunctorDelegate *)jarg3;
53665   {
53666     try {
53667       (arg1)->Connect(arg2,arg3);
53668     } catch (std::out_of_range& e) {
53669       {
53670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53671       };
53672     } catch (std::exception& e) {
53673       {
53674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53675       };
53676     } catch (Dali::DaliException e) {
53677       {
53678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53679       };
53680     } catch (...) {
53681       {
53682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53683       };
53684     }
53685   }
53686
53687 }
53688
53689
53690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53691   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53692
53693   arg1 = (Dali::Signal< void () > *)jarg1;
53694   {
53695     try {
53696       (arg1)->Emit();
53697     } catch (std::out_of_range& e) {
53698       {
53699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53700       };
53701     } catch (std::exception& e) {
53702       {
53703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53704       };
53705     } catch (Dali::DaliException e) {
53706       {
53707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53708       };
53709     } catch (...) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53712       };
53713     }
53714   }
53715
53716 }
53717
53718
53719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53720   unsigned int jresult ;
53721   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53722   bool result;
53723
53724   arg1 = (Dali::Signal< void (float) > *)jarg1;
53725   {
53726     try {
53727       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53728     } catch (std::out_of_range& e) {
53729       {
53730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53731       };
53732     } catch (std::exception& e) {
53733       {
53734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53735       };
53736     } catch (Dali::DaliException e) {
53737       {
53738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53739       };
53740     } catch (...) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53743       };
53744     }
53745   }
53746
53747   jresult = result;
53748   return jresult;
53749 }
53750
53751
53752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53753   unsigned long jresult ;
53754   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53755   std::size_t result;
53756
53757   arg1 = (Dali::Signal< void (float) > *)jarg1;
53758   {
53759     try {
53760       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53761     } catch (std::out_of_range& e) {
53762       {
53763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53764       };
53765     } catch (std::exception& e) {
53766       {
53767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (Dali::DaliException e) {
53770       {
53771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53772       };
53773     } catch (...) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53776       };
53777     }
53778   }
53779
53780   jresult = (unsigned long)result;
53781   return jresult;
53782 }
53783
53784
53785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53786   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53787   void (*arg2)(float) = (void (*)(float)) 0 ;
53788
53789   arg1 = (Dali::Signal< void (float) > *)jarg1;
53790   arg2 = (void (*)(float))jarg2;
53791   {
53792     try {
53793       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53794     } catch (std::out_of_range& e) {
53795       {
53796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53797       };
53798     } catch (std::exception& e) {
53799       {
53800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53801       };
53802     } catch (Dali::DaliException e) {
53803       {
53804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53805       };
53806     } catch (...) {
53807       {
53808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53809       };
53810     }
53811   }
53812
53813 }
53814
53815
53816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53817   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53818   void (*arg2)(float) = (void (*)(float)) 0 ;
53819
53820   arg1 = (Dali::Signal< void (float) > *)jarg1;
53821   arg2 = (void (*)(float))jarg2;
53822   {
53823     try {
53824       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53825     } catch (std::out_of_range& e) {
53826       {
53827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53828       };
53829     } catch (std::exception& e) {
53830       {
53831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53832       };
53833     } catch (Dali::DaliException e) {
53834       {
53835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53836       };
53837     } catch (...) {
53838       {
53839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53840       };
53841     }
53842   }
53843
53844 }
53845
53846
53847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53848   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53849   float arg2 ;
53850
53851   arg1 = (Dali::Signal< void (float) > *)jarg1;
53852   arg2 = (float)jarg2;
53853   {
53854     try {
53855       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53856     } catch (std::out_of_range& e) {
53857       {
53858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53859       };
53860     } catch (std::exception& e) {
53861       {
53862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53863       };
53864     } catch (Dali::DaliException e) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53867       };
53868     } catch (...) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53871       };
53872     }
53873   }
53874
53875 }
53876
53877
53878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
53879   void * jresult ;
53880   Dali::Signal< void (float) > *result = 0 ;
53881
53882   {
53883     try {
53884       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
53885     } catch (std::out_of_range& e) {
53886       {
53887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53888       };
53889     } catch (std::exception& e) {
53890       {
53891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53892       };
53893     } catch (Dali::DaliException e) {
53894       {
53895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53896       };
53897     } catch (...) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53900       };
53901     }
53902   }
53903
53904   jresult = (void *)result;
53905   return jresult;
53906 }
53907
53908
53909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
53910   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53911
53912   arg1 = (Dali::Signal< void (float) > *)jarg1;
53913   {
53914     try {
53915       delete arg1;
53916     } catch (std::out_of_range& e) {
53917       {
53918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53919       };
53920     } catch (std::exception& e) {
53921       {
53922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53923       };
53924     } catch (Dali::DaliException e) {
53925       {
53926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53927       };
53928     } catch (...) {
53929       {
53930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53931       };
53932     }
53933   }
53934
53935 }
53936
53937
53938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
53939   unsigned int jresult ;
53940   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53941   bool result;
53942
53943   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53944   {
53945     try {
53946       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53947     } catch (std::out_of_range& e) {
53948       {
53949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53950       };
53951     } catch (std::exception& e) {
53952       {
53953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53954       };
53955     } catch (Dali::DaliException e) {
53956       {
53957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53958       };
53959     } catch (...) {
53960       {
53961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53962       };
53963     }
53964   }
53965
53966   jresult = result;
53967   return jresult;
53968 }
53969
53970
53971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
53972   unsigned long jresult ;
53973   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53974   std::size_t result;
53975
53976   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53977   {
53978     try {
53979       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
53980     } catch (std::out_of_range& e) {
53981       {
53982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53983       };
53984     } catch (std::exception& e) {
53985       {
53986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53987       };
53988     } catch (Dali::DaliException e) {
53989       {
53990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53991       };
53992     } catch (...) {
53993       {
53994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53995       };
53996     }
53997   }
53998
53999   jresult = (unsigned long)result;
54000   return jresult;
54001 }
54002
54003
54004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54005   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54006   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54007
54008   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54009   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54010   {
54011     try {
54012       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54013     } catch (std::out_of_range& e) {
54014       {
54015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54016       };
54017     } catch (std::exception& e) {
54018       {
54019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54020       };
54021     } catch (Dali::DaliException e) {
54022       {
54023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54024       };
54025     } catch (...) {
54026       {
54027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54028       };
54029     }
54030   }
54031
54032 }
54033
54034
54035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54036   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54037   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54038
54039   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54040   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54041   {
54042     try {
54043       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54044     } catch (std::out_of_range& e) {
54045       {
54046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54047       };
54048     } catch (std::exception& e) {
54049       {
54050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54051       };
54052     } catch (Dali::DaliException e) {
54053       {
54054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54055       };
54056     } catch (...) {
54057       {
54058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54059       };
54060     }
54061   }
54062
54063 }
54064
54065
54066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54067   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54068   Dali::BaseHandle arg2 ;
54069   Dali::BaseHandle *argp2 ;
54070
54071   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54072   argp2 = (Dali::BaseHandle *)jarg2;
54073   if (!argp2) {
54074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54075     return ;
54076   }
54077   arg2 = *argp2;
54078   {
54079     try {
54080       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54081     } catch (std::out_of_range& e) {
54082       {
54083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54084       };
54085     } catch (std::exception& e) {
54086       {
54087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54088       };
54089     } catch (Dali::DaliException e) {
54090       {
54091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54092       };
54093     } catch (...) {
54094       {
54095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54096       };
54097     }
54098   }
54099
54100 }
54101
54102
54103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54104   void * jresult ;
54105   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54106
54107   {
54108     try {
54109       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54110     } catch (std::out_of_range& e) {
54111       {
54112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54113       };
54114     } catch (std::exception& e) {
54115       {
54116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54117       };
54118     } catch (Dali::DaliException e) {
54119       {
54120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54121       };
54122     } catch (...) {
54123       {
54124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54125       };
54126     }
54127   }
54128
54129   jresult = (void *)result;
54130   return jresult;
54131 }
54132
54133
54134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54135   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54136
54137   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54138   {
54139     try {
54140       delete arg1;
54141     } catch (std::out_of_range& e) {
54142       {
54143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54144       };
54145     } catch (std::exception& e) {
54146       {
54147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54148       };
54149     } catch (Dali::DaliException e) {
54150       {
54151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54152       };
54153     } catch (...) {
54154       {
54155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54156       };
54157     }
54158   }
54159
54160 }
54161
54162
54163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54164   unsigned int jresult ;
54165   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54166   bool result;
54167
54168   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54169   {
54170     try {
54171       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54172     } catch (std::out_of_range& e) {
54173       {
54174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54175       };
54176     } catch (std::exception& e) {
54177       {
54178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54179       };
54180     } catch (Dali::DaliException e) {
54181       {
54182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54183       };
54184     } catch (...) {
54185       {
54186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54187       };
54188     }
54189   }
54190
54191   jresult = result;
54192   return jresult;
54193 }
54194
54195
54196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54197   unsigned long jresult ;
54198   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54199   std::size_t result;
54200
54201   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54202   {
54203     try {
54204       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54205     } catch (std::out_of_range& e) {
54206       {
54207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54208       };
54209     } catch (std::exception& e) {
54210       {
54211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54212       };
54213     } catch (Dali::DaliException e) {
54214       {
54215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54216       };
54217     } catch (...) {
54218       {
54219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54220       };
54221     }
54222   }
54223
54224   jresult = (unsigned long)result;
54225   return jresult;
54226 }
54227
54228
54229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54230   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54231   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54232
54233   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54234   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54235   {
54236     try {
54237       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54238     } catch (std::out_of_range& e) {
54239       {
54240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54241       };
54242     } catch (std::exception& e) {
54243       {
54244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54245       };
54246     } catch (Dali::DaliException e) {
54247       {
54248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54249       };
54250     } catch (...) {
54251       {
54252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54253       };
54254     }
54255   }
54256
54257 }
54258
54259
54260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54261   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54262   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54263
54264   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54265   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54266   {
54267     try {
54268       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54269     } catch (std::out_of_range& e) {
54270       {
54271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54272       };
54273     } catch (std::exception& e) {
54274       {
54275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54276       };
54277     } catch (Dali::DaliException e) {
54278       {
54279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54280       };
54281     } catch (...) {
54282       {
54283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54284       };
54285     }
54286   }
54287
54288 }
54289
54290
54291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54292   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54293   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54294
54295   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54296   arg2 = (Dali::RefObject *)jarg2;
54297   {
54298     try {
54299       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54300     } catch (std::out_of_range& e) {
54301       {
54302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54303       };
54304     } catch (std::exception& e) {
54305       {
54306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54307       };
54308     } catch (Dali::DaliException e) {
54309       {
54310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54311       };
54312     } catch (...) {
54313       {
54314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54315       };
54316     }
54317   }
54318
54319 }
54320
54321
54322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54323   void * jresult ;
54324   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54325
54326   {
54327     try {
54328       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54329     } catch (std::out_of_range& e) {
54330       {
54331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54332       };
54333     } catch (std::exception& e) {
54334       {
54335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54336       };
54337     } catch (Dali::DaliException e) {
54338       {
54339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54340       };
54341     } catch (...) {
54342       {
54343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54344       };
54345     }
54346   }
54347
54348   jresult = (void *)result;
54349   return jresult;
54350 }
54351
54352
54353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54354   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54355
54356   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54357   {
54358     try {
54359       delete arg1;
54360     } catch (std::out_of_range& e) {
54361       {
54362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54363       };
54364     } catch (std::exception& e) {
54365       {
54366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54367       };
54368     } catch (Dali::DaliException e) {
54369       {
54370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54371       };
54372     } catch (...) {
54373       {
54374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54375       };
54376     }
54377   }
54378
54379 }
54380
54381
54382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54383   unsigned int jresult ;
54384   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54385   bool result;
54386
54387   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54388   {
54389     try {
54390       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54391     } catch (std::out_of_range& e) {
54392       {
54393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54394       };
54395     } catch (std::exception& e) {
54396       {
54397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54398       };
54399     } catch (Dali::DaliException e) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54402       };
54403     } catch (...) {
54404       {
54405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54406       };
54407     }
54408   }
54409
54410   jresult = result;
54411   return jresult;
54412 }
54413
54414
54415 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54416   unsigned long jresult ;
54417   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54418   std::size_t result;
54419
54420   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54421   {
54422     try {
54423       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54424     } catch (std::out_of_range& e) {
54425       {
54426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54427       };
54428     } catch (std::exception& e) {
54429       {
54430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54431       };
54432     } catch (Dali::DaliException e) {
54433       {
54434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54435       };
54436     } catch (...) {
54437       {
54438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54439       };
54440     }
54441   }
54442
54443   jresult = (unsigned long)result;
54444   return jresult;
54445 }
54446
54447
54448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54449   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54450   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54451
54452   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54453   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54454   {
54455     try {
54456       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54457     } catch (std::out_of_range& e) {
54458       {
54459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54460       };
54461     } catch (std::exception& e) {
54462       {
54463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54464       };
54465     } catch (Dali::DaliException e) {
54466       {
54467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54468       };
54469     } catch (...) {
54470       {
54471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54472       };
54473     }
54474   }
54475
54476 }
54477
54478
54479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54480   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54481   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54482
54483   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54484   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54485   {
54486     try {
54487       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54488     } catch (std::out_of_range& e) {
54489       {
54490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54491       };
54492     } catch (std::exception& e) {
54493       {
54494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54495       };
54496     } catch (Dali::DaliException e) {
54497       {
54498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54499       };
54500     } catch (...) {
54501       {
54502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54503       };
54504     }
54505   }
54506
54507 }
54508
54509
54510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54511   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54512   Dali::PropertyNotification *arg2 = 0 ;
54513
54514   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54515   arg2 = (Dali::PropertyNotification *)jarg2;
54516   if (!arg2) {
54517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54518     return ;
54519   }
54520   {
54521     try {
54522       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54523     } catch (std::out_of_range& e) {
54524       {
54525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54526       };
54527     } catch (std::exception& e) {
54528       {
54529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54530       };
54531     } catch (Dali::DaliException e) {
54532       {
54533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54534       };
54535     } catch (...) {
54536       {
54537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54538       };
54539     }
54540   }
54541
54542 }
54543
54544
54545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54546   void * jresult ;
54547   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54548
54549   {
54550     try {
54551       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54552     } catch (std::out_of_range& e) {
54553       {
54554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54555       };
54556     } catch (std::exception& e) {
54557       {
54558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54559       };
54560     } catch (Dali::DaliException e) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54563       };
54564     } catch (...) {
54565       {
54566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54567       };
54568     }
54569   }
54570
54571   jresult = (void *)result;
54572   return jresult;
54573 }
54574
54575
54576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54577   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54578
54579   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54580   {
54581     try {
54582       delete arg1;
54583     } catch (std::out_of_range& e) {
54584       {
54585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54586       };
54587     } catch (std::exception& e) {
54588       {
54589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54590       };
54591     } catch (Dali::DaliException e) {
54592       {
54593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54594       };
54595     } catch (...) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54598       };
54599     }
54600   }
54601
54602 }
54603
54604
54605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54606   unsigned int jresult ;
54607   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54608   bool result;
54609
54610   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54611   {
54612     try {
54613       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54614     } catch (std::out_of_range& e) {
54615       {
54616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54617       };
54618     } catch (std::exception& e) {
54619       {
54620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54621       };
54622     } catch (Dali::DaliException e) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54625       };
54626     } catch (...) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54629       };
54630     }
54631   }
54632
54633   jresult = result;
54634   return jresult;
54635 }
54636
54637
54638 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54639   unsigned long jresult ;
54640   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54641   std::size_t result;
54642
54643   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54644   {
54645     try {
54646       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54647     } catch (std::out_of_range& e) {
54648       {
54649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54650       };
54651     } catch (std::exception& e) {
54652       {
54653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54654       };
54655     } catch (Dali::DaliException e) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54658       };
54659     } catch (...) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54662       };
54663     }
54664   }
54665
54666   jresult = (unsigned long)result;
54667   return jresult;
54668 }
54669
54670
54671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54672   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54673   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54674
54675   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54676   arg2 = (void (*)(Dali::Image))jarg2;
54677   {
54678     try {
54679       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54680     } catch (std::out_of_range& e) {
54681       {
54682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54683       };
54684     } catch (std::exception& e) {
54685       {
54686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54687       };
54688     } catch (Dali::DaliException e) {
54689       {
54690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54691       };
54692     } catch (...) {
54693       {
54694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54695       };
54696     }
54697   }
54698
54699 }
54700
54701
54702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54703   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54704   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54705
54706   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54707   arg2 = (void (*)(Dali::Image))jarg2;
54708   {
54709     try {
54710       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54711     } catch (std::out_of_range& e) {
54712       {
54713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54714       };
54715     } catch (std::exception& e) {
54716       {
54717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (Dali::DaliException e) {
54720       {
54721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54722       };
54723     } catch (...) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54726       };
54727     }
54728   }
54729
54730 }
54731
54732
54733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54734   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54735   Dali::Image arg2 ;
54736   Dali::Image *argp2 ;
54737
54738   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54739   argp2 = (Dali::Image *)jarg2;
54740   if (!argp2) {
54741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54742     return ;
54743   }
54744   arg2 = *argp2;
54745   {
54746     try {
54747       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54748     } catch (std::out_of_range& e) {
54749       {
54750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54751       };
54752     } catch (std::exception& e) {
54753       {
54754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54755       };
54756     } catch (Dali::DaliException e) {
54757       {
54758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54759       };
54760     } catch (...) {
54761       {
54762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54763       };
54764     }
54765   }
54766
54767 }
54768
54769
54770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54771   void * jresult ;
54772   Dali::Signal< void (Dali::Image) > *result = 0 ;
54773
54774   {
54775     try {
54776       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54777     } catch (std::out_of_range& e) {
54778       {
54779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54780       };
54781     } catch (std::exception& e) {
54782       {
54783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54784       };
54785     } catch (Dali::DaliException e) {
54786       {
54787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54788       };
54789     } catch (...) {
54790       {
54791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54792       };
54793     }
54794   }
54795
54796   jresult = (void *)result;
54797   return jresult;
54798 }
54799
54800
54801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54802   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54803
54804   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54805   {
54806     try {
54807       delete arg1;
54808     } catch (std::out_of_range& e) {
54809       {
54810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54811       };
54812     } catch (std::exception& e) {
54813       {
54814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54815       };
54816     } catch (Dali::DaliException e) {
54817       {
54818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54819       };
54820     } catch (...) {
54821       {
54822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54823       };
54824     }
54825   }
54826
54827 }
54828
54829
54830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54831   void * jresult ;
54832   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54833
54834   {
54835     try {
54836       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54837     } catch (std::out_of_range& e) {
54838       {
54839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54840       };
54841     } catch (std::exception& e) {
54842       {
54843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (Dali::DaliException e) {
54846       {
54847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54848       };
54849     } catch (...) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54852       };
54853     }
54854   }
54855
54856   jresult = (void *)result;
54857   return jresult;
54858 }
54859
54860
54861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54862   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54863
54864   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
54865   {
54866     try {
54867       delete arg1;
54868     } catch (std::out_of_range& e) {
54869       {
54870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54871       };
54872     } catch (std::exception& e) {
54873       {
54874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54875       };
54876     } catch (Dali::DaliException e) {
54877       {
54878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54879       };
54880     } catch (...) {
54881       {
54882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54883       };
54884     }
54885   }
54886
54887 }
54888
54889
54890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
54891   unsigned int jresult ;
54892   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54893   bool result;
54894
54895   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54896   {
54897     try {
54898       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);
54899     } catch (std::out_of_range& e) {
54900       {
54901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54902       };
54903     } catch (std::exception& e) {
54904       {
54905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54906       };
54907     } catch (Dali::DaliException e) {
54908       {
54909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54910       };
54911     } catch (...) {
54912       {
54913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54914       };
54915     }
54916   }
54917
54918   jresult = result;
54919   return jresult;
54920 }
54921
54922
54923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54924   unsigned long jresult ;
54925   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54926   std::size_t result;
54927
54928   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54929   {
54930     try {
54931       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);
54932     } catch (std::out_of_range& e) {
54933       {
54934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54935       };
54936     } catch (std::exception& e) {
54937       {
54938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54939       };
54940     } catch (Dali::DaliException e) {
54941       {
54942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54943       };
54944     } catch (...) {
54945       {
54946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54947       };
54948     }
54949   }
54950
54951   jresult = (unsigned long)result;
54952   return jresult;
54953 }
54954
54955
54956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54957   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54958   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54959
54960   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54961   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54962   {
54963     try {
54964       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54965     } catch (std::out_of_range& e) {
54966       {
54967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54968       };
54969     } catch (std::exception& e) {
54970       {
54971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54972       };
54973     } catch (Dali::DaliException e) {
54974       {
54975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54976       };
54977     } catch (...) {
54978       {
54979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54980       };
54981     }
54982   }
54983
54984 }
54985
54986
54987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54988   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54989   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
54990
54991   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54992   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
54993   {
54994     try {
54995       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54996     } catch (std::out_of_range& e) {
54997       {
54998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54999       };
55000     } catch (std::exception& e) {
55001       {
55002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55003       };
55004     } catch (Dali::DaliException e) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55007       };
55008     } catch (...) {
55009       {
55010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55011       };
55012     }
55013   }
55014
55015 }
55016
55017
55018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55019   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55020   Dali::Actor arg2 ;
55021   Dali::LongPressGesture *arg3 = 0 ;
55022   Dali::Actor *argp2 ;
55023
55024   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55025   argp2 = (Dali::Actor *)jarg2;
55026   if (!argp2) {
55027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55028     return ;
55029   }
55030   arg2 = *argp2;
55031   arg3 = (Dali::LongPressGesture *)jarg3;
55032   if (!arg3) {
55033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55034     return ;
55035   }
55036   {
55037     try {
55038       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55039     } catch (std::out_of_range& e) {
55040       {
55041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55042       };
55043     } catch (std::exception& e) {
55044       {
55045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55046       };
55047     } catch (Dali::DaliException e) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55050       };
55051     } catch (...) {
55052       {
55053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55054       };
55055     }
55056   }
55057
55058 }
55059
55060
55061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55062   void * jresult ;
55063   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55064
55065   {
55066     try {
55067       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55068     } catch (std::out_of_range& e) {
55069       {
55070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (std::exception& e) {
55073       {
55074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (Dali::DaliException e) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55079       };
55080     } catch (...) {
55081       {
55082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55083       };
55084     }
55085   }
55086
55087   jresult = (void *)result;
55088   return jresult;
55089 }
55090
55091
55092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55093   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55094
55095   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55096   {
55097     try {
55098       delete arg1;
55099     } catch (std::out_of_range& e) {
55100       {
55101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55102       };
55103     } catch (std::exception& e) {
55104       {
55105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55106       };
55107     } catch (Dali::DaliException e) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55110       };
55111     } catch (...) {
55112       {
55113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55114       };
55115     }
55116   }
55117
55118 }
55119
55120
55121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55122   unsigned int jresult ;
55123   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55124   bool result;
55125
55126   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55127   {
55128     try {
55129       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);
55130     } catch (std::out_of_range& e) {
55131       {
55132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (std::exception& e) {
55135       {
55136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55137       };
55138     } catch (Dali::DaliException e) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55141       };
55142     } catch (...) {
55143       {
55144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55145       };
55146     }
55147   }
55148
55149   jresult = result;
55150   return jresult;
55151 }
55152
55153
55154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55155   unsigned long jresult ;
55156   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55157   std::size_t result;
55158
55159   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55160   {
55161     try {
55162       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);
55163     } catch (std::out_of_range& e) {
55164       {
55165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (std::exception& e) {
55168       {
55169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55170       };
55171     } catch (Dali::DaliException e) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55174       };
55175     } catch (...) {
55176       {
55177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55178       };
55179     }
55180   }
55181
55182   jresult = (unsigned long)result;
55183   return jresult;
55184 }
55185
55186
55187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55188   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55189   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55190
55191   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55192   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55193   {
55194     try {
55195       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55203       };
55204     } catch (Dali::DaliException e) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55211       };
55212     }
55213   }
55214
55215 }
55216
55217
55218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55219   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55220   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55221
55222   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55223   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55224   {
55225     try {
55226       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55234       };
55235     } catch (Dali::DaliException e) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55238       };
55239     } catch (...) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55242       };
55243     }
55244   }
55245
55246 }
55247
55248
55249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55250   unsigned int jresult ;
55251   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55252   Dali::Actor arg2 ;
55253   Dali::TouchData *arg3 = 0 ;
55254   Dali::Actor *argp2 ;
55255   bool result;
55256
55257   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55258   argp2 = (Dali::Actor *)jarg2;
55259   if (!argp2) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55261     return 0;
55262   }
55263   arg2 = *argp2;
55264   arg3 = (Dali::TouchData *)jarg3;
55265   if (!arg3) {
55266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55267     return 0;
55268   }
55269   {
55270     try {
55271       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55272     } catch (std::out_of_range& e) {
55273       {
55274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55275       };
55276     } catch (std::exception& e) {
55277       {
55278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55279       };
55280     } catch (Dali::DaliException e) {
55281       {
55282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55283       };
55284     } catch (...) {
55285       {
55286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55287       };
55288     }
55289   }
55290
55291   jresult = result;
55292   return jresult;
55293 }
55294
55295
55296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55297   void * jresult ;
55298   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55299
55300   {
55301     try {
55302       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55303     } catch (std::out_of_range& e) {
55304       {
55305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55306       };
55307     } catch (std::exception& e) {
55308       {
55309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55310       };
55311     } catch (Dali::DaliException e) {
55312       {
55313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55314       };
55315     } catch (...) {
55316       {
55317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55318       };
55319     }
55320   }
55321
55322   jresult = (void *)result;
55323   return jresult;
55324 }
55325
55326
55327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55328   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55329
55330   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55331   {
55332     try {
55333       delete arg1;
55334     } catch (std::out_of_range& e) {
55335       {
55336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55337       };
55338     } catch (std::exception& e) {
55339       {
55340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55341       };
55342     } catch (Dali::DaliException e) {
55343       {
55344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55345       };
55346     } catch (...) {
55347       {
55348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55349       };
55350     }
55351   }
55352
55353 }
55354
55355
55356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55357   unsigned int jresult ;
55358   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55359   bool result;
55360
55361   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55362   {
55363     try {
55364       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);
55365     } catch (std::out_of_range& e) {
55366       {
55367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55368       };
55369     } catch (std::exception& e) {
55370       {
55371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55372       };
55373     } catch (Dali::DaliException e) {
55374       {
55375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55376       };
55377     } catch (...) {
55378       {
55379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55380       };
55381     }
55382   }
55383
55384   jresult = result;
55385   return jresult;
55386 }
55387
55388
55389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55390   unsigned long jresult ;
55391   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55392   std::size_t result;
55393
55394   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55395   {
55396     try {
55397       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);
55398     } catch (std::out_of_range& e) {
55399       {
55400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55401       };
55402     } catch (std::exception& e) {
55403       {
55404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55405       };
55406     } catch (Dali::DaliException e) {
55407       {
55408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55409       };
55410     } catch (...) {
55411       {
55412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55413       };
55414     }
55415   }
55416
55417   jresult = (unsigned long)result;
55418   return jresult;
55419 }
55420
55421
55422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55423   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55424   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55425
55426   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55427   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55428   {
55429     try {
55430       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55431     } catch (std::out_of_range& e) {
55432       {
55433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55434       };
55435     } catch (std::exception& e) {
55436       {
55437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55438       };
55439     } catch (Dali::DaliException e) {
55440       {
55441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55442       };
55443     } catch (...) {
55444       {
55445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55446       };
55447     }
55448   }
55449
55450 }
55451
55452
55453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55454   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55455   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55456
55457   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55458   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55459   {
55460     try {
55461       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55462     } catch (std::out_of_range& e) {
55463       {
55464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55465       };
55466     } catch (std::exception& e) {
55467       {
55468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55469       };
55470     } catch (Dali::DaliException e) {
55471       {
55472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55473       };
55474     } catch (...) {
55475       {
55476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55477       };
55478     }
55479   }
55480
55481 }
55482
55483
55484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55485   unsigned int jresult ;
55486   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55487   Dali::Actor arg2 ;
55488   Dali::HoverEvent *arg3 = 0 ;
55489   Dali::Actor *argp2 ;
55490   bool result;
55491
55492   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55493   argp2 = (Dali::Actor *)jarg2;
55494   if (!argp2) {
55495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55496     return 0;
55497   }
55498   arg2 = *argp2;
55499   arg3 = (Dali::HoverEvent *)jarg3;
55500   if (!arg3) {
55501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55502     return 0;
55503   }
55504   {
55505     try {
55506       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55507     } catch (std::out_of_range& e) {
55508       {
55509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55510       };
55511     } catch (std::exception& e) {
55512       {
55513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55514       };
55515     } catch (Dali::DaliException e) {
55516       {
55517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55518       };
55519     } catch (...) {
55520       {
55521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55522       };
55523     }
55524   }
55525
55526   jresult = result;
55527   return jresult;
55528 }
55529
55530
55531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55532   void * jresult ;
55533   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55534
55535   {
55536     try {
55537       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55538     } catch (std::out_of_range& e) {
55539       {
55540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55541       };
55542     } catch (std::exception& e) {
55543       {
55544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (Dali::DaliException e) {
55547       {
55548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55549       };
55550     } catch (...) {
55551       {
55552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55553       };
55554     }
55555   }
55556
55557   jresult = (void *)result;
55558   return jresult;
55559 }
55560
55561
55562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55563   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55564
55565   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55566   {
55567     try {
55568       delete arg1;
55569     } catch (std::out_of_range& e) {
55570       {
55571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55572       };
55573     } catch (std::exception& e) {
55574       {
55575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55576       };
55577     } catch (Dali::DaliException e) {
55578       {
55579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55580       };
55581     } catch (...) {
55582       {
55583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55584       };
55585     }
55586   }
55587
55588 }
55589
55590
55591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55592   unsigned int jresult ;
55593   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55594   bool result;
55595
55596   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55597   {
55598     try {
55599       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);
55600     } catch (std::out_of_range& e) {
55601       {
55602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55603       };
55604     } catch (std::exception& e) {
55605       {
55606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55607       };
55608     } catch (Dali::DaliException e) {
55609       {
55610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55611       };
55612     } catch (...) {
55613       {
55614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55615       };
55616     }
55617   }
55618
55619   jresult = result;
55620   return jresult;
55621 }
55622
55623
55624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55625   unsigned long jresult ;
55626   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55627   std::size_t result;
55628
55629   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55630   {
55631     try {
55632       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);
55633     } catch (std::out_of_range& e) {
55634       {
55635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55636       };
55637     } catch (std::exception& e) {
55638       {
55639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55640       };
55641     } catch (Dali::DaliException e) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55644       };
55645     } catch (...) {
55646       {
55647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55648       };
55649     }
55650   }
55651
55652   jresult = (unsigned long)result;
55653   return jresult;
55654 }
55655
55656
55657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55658   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55659   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55660
55661   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55662   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55663   {
55664     try {
55665       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55666     } catch (std::out_of_range& e) {
55667       {
55668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55669       };
55670     } catch (std::exception& e) {
55671       {
55672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55673       };
55674     } catch (Dali::DaliException e) {
55675       {
55676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55677       };
55678     } catch (...) {
55679       {
55680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55681       };
55682     }
55683   }
55684
55685 }
55686
55687
55688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55689   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55690   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55691
55692   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55693   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55694   {
55695     try {
55696       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55697     } catch (std::out_of_range& e) {
55698       {
55699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55700       };
55701     } catch (std::exception& e) {
55702       {
55703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55704       };
55705     } catch (Dali::DaliException e) {
55706       {
55707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55708       };
55709     } catch (...) {
55710       {
55711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55712       };
55713     }
55714   }
55715
55716 }
55717
55718
55719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55720   unsigned int jresult ;
55721   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55722   Dali::Actor arg2 ;
55723   Dali::WheelEvent *arg3 = 0 ;
55724   Dali::Actor *argp2 ;
55725   bool result;
55726
55727   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55728   argp2 = (Dali::Actor *)jarg2;
55729   if (!argp2) {
55730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55731     return 0;
55732   }
55733   arg2 = *argp2;
55734   arg3 = (Dali::WheelEvent *)jarg3;
55735   if (!arg3) {
55736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55737     return 0;
55738   }
55739   {
55740     try {
55741       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55742     } catch (std::out_of_range& e) {
55743       {
55744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55745       };
55746     } catch (std::exception& e) {
55747       {
55748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55749       };
55750     } catch (Dali::DaliException e) {
55751       {
55752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55753       };
55754     } catch (...) {
55755       {
55756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55757       };
55758     }
55759   }
55760
55761   jresult = result;
55762   return jresult;
55763 }
55764
55765
55766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55767   void * jresult ;
55768   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55769
55770   {
55771     try {
55772       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55773     } catch (std::out_of_range& e) {
55774       {
55775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55776       };
55777     } catch (std::exception& e) {
55778       {
55779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55780       };
55781     } catch (Dali::DaliException e) {
55782       {
55783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55784       };
55785     } catch (...) {
55786       {
55787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55788       };
55789     }
55790   }
55791
55792   jresult = (void *)result;
55793   return jresult;
55794 }
55795
55796
55797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55798   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55799
55800   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55801   {
55802     try {
55803       delete arg1;
55804     } catch (std::out_of_range& e) {
55805       {
55806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55807       };
55808     } catch (std::exception& e) {
55809       {
55810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55811       };
55812     } catch (Dali::DaliException e) {
55813       {
55814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55815       };
55816     } catch (...) {
55817       {
55818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55819       };
55820     }
55821   }
55822
55823 }
55824
55825
55826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55827   unsigned int jresult ;
55828   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55829   bool result;
55830
55831   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55832   {
55833     try {
55834       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55835     } catch (std::out_of_range& e) {
55836       {
55837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55838       };
55839     } catch (std::exception& e) {
55840       {
55841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55842       };
55843     } catch (Dali::DaliException e) {
55844       {
55845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55846       };
55847     } catch (...) {
55848       {
55849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55850       };
55851     }
55852   }
55853
55854   jresult = result;
55855   return jresult;
55856 }
55857
55858
55859 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55860   unsigned long jresult ;
55861   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55862   std::size_t result;
55863
55864   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55865   {
55866     try {
55867       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
55868     } catch (std::out_of_range& e) {
55869       {
55870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55871       };
55872     } catch (std::exception& e) {
55873       {
55874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55875       };
55876     } catch (Dali::DaliException e) {
55877       {
55878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55879       };
55880     } catch (...) {
55881       {
55882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55883       };
55884     }
55885   }
55886
55887   jresult = (unsigned long)result;
55888   return jresult;
55889 }
55890
55891
55892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
55893   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55894   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55895
55896   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55897   arg2 = (void (*)(Dali::Actor))jarg2;
55898   {
55899     try {
55900       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
55901     } catch (std::out_of_range& e) {
55902       {
55903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55904       };
55905     } catch (std::exception& e) {
55906       {
55907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55908       };
55909     } catch (Dali::DaliException e) {
55910       {
55911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55912       };
55913     } catch (...) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55916       };
55917     }
55918   }
55919
55920 }
55921
55922
55923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
55924   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55925   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
55926
55927   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55928   arg2 = (void (*)(Dali::Actor))jarg2;
55929   {
55930     try {
55931       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
55932     } catch (std::out_of_range& e) {
55933       {
55934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55935       };
55936     } catch (std::exception& e) {
55937       {
55938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55939       };
55940     } catch (Dali::DaliException e) {
55941       {
55942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55943       };
55944     } catch (...) {
55945       {
55946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55947       };
55948     }
55949   }
55950
55951 }
55952
55953
55954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
55955   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55956   Dali::Actor arg2 ;
55957   Dali::Actor *argp2 ;
55958
55959   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55960   argp2 = (Dali::Actor *)jarg2;
55961   if (!argp2) {
55962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55963     return ;
55964   }
55965   arg2 = *argp2;
55966   {
55967     try {
55968       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
55969     } catch (std::out_of_range& e) {
55970       {
55971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55972       };
55973     } catch (std::exception& e) {
55974       {
55975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55976       };
55977     } catch (Dali::DaliException e) {
55978       {
55979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55980       };
55981     } catch (...) {
55982       {
55983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55984       };
55985     }
55986   }
55987
55988 }
55989
55990
55991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
55992   void * jresult ;
55993   Dali::Signal< void (Dali::Actor) > *result = 0 ;
55994
55995   {
55996     try {
55997       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
55998     } catch (std::out_of_range& e) {
55999       {
56000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56001       };
56002     } catch (std::exception& e) {
56003       {
56004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56005       };
56006     } catch (Dali::DaliException e) {
56007       {
56008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56009       };
56010     } catch (...) {
56011       {
56012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56013       };
56014     }
56015   }
56016
56017   jresult = (void *)result;
56018   return jresult;
56019 }
56020
56021
56022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56023   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56024
56025   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56026   {
56027     try {
56028       delete arg1;
56029     } catch (std::out_of_range& e) {
56030       {
56031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56032       };
56033     } catch (std::exception& e) {
56034       {
56035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56036       };
56037     } catch (Dali::DaliException e) {
56038       {
56039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56040       };
56041     } catch (...) {
56042       {
56043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56044       };
56045     }
56046   }
56047
56048 }
56049
56050
56051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56052   unsigned int jresult ;
56053   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56054   bool result;
56055
56056   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56057   {
56058     try {
56059       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56060     } catch (std::out_of_range& e) {
56061       {
56062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56063       };
56064     } catch (std::exception& e) {
56065       {
56066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56067       };
56068     } catch (Dali::DaliException e) {
56069       {
56070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56071       };
56072     } catch (...) {
56073       {
56074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56075       };
56076     }
56077   }
56078
56079   jresult = result;
56080   return jresult;
56081 }
56082
56083
56084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56085   unsigned long jresult ;
56086   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56087   std::size_t result;
56088
56089   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56090   {
56091     try {
56092       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56093     } catch (std::out_of_range& e) {
56094       {
56095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56096       };
56097     } catch (std::exception& e) {
56098       {
56099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56100       };
56101     } catch (Dali::DaliException e) {
56102       {
56103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56104       };
56105     } catch (...) {
56106       {
56107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56108       };
56109     }
56110   }
56111
56112   jresult = (unsigned long)result;
56113   return jresult;
56114 }
56115
56116
56117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56118   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56119   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56120
56121   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56122   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56123   {
56124     try {
56125       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56126     } catch (std::out_of_range& e) {
56127       {
56128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56129       };
56130     } catch (std::exception& e) {
56131       {
56132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56133       };
56134     } catch (Dali::DaliException e) {
56135       {
56136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56137       };
56138     } catch (...) {
56139       {
56140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56141       };
56142     }
56143   }
56144
56145 }
56146
56147
56148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56149   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56150   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56151
56152   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56153   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56154   {
56155     try {
56156       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56157     } catch (std::out_of_range& e) {
56158       {
56159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56160       };
56161     } catch (std::exception& e) {
56162       {
56163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56164       };
56165     } catch (Dali::DaliException e) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56168       };
56169     } catch (...) {
56170       {
56171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56172       };
56173     }
56174   }
56175
56176 }
56177
56178
56179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56180   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56181   Dali::KeyEvent *arg2 = 0 ;
56182
56183   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56184   arg2 = (Dali::KeyEvent *)jarg2;
56185   if (!arg2) {
56186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56187     return ;
56188   }
56189   {
56190     try {
56191       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56192     } catch (std::out_of_range& e) {
56193       {
56194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56195       };
56196     } catch (std::exception& e) {
56197       {
56198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56199       };
56200     } catch (Dali::DaliException e) {
56201       {
56202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56203       };
56204     } catch (...) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56207       };
56208     }
56209   }
56210
56211 }
56212
56213
56214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56215   void * jresult ;
56216   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56217
56218   {
56219     try {
56220       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56221     } catch (std::out_of_range& e) {
56222       {
56223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (std::exception& e) {
56226       {
56227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (Dali::DaliException e) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56232       };
56233     } catch (...) {
56234       {
56235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56236       };
56237     }
56238   }
56239
56240   jresult = (void *)result;
56241   return jresult;
56242 }
56243
56244
56245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56246   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56247
56248   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56249   {
56250     try {
56251       delete arg1;
56252     } catch (std::out_of_range& e) {
56253       {
56254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56255       };
56256     } catch (std::exception& e) {
56257       {
56258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56259       };
56260     } catch (Dali::DaliException e) {
56261       {
56262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56263       };
56264     } catch (...) {
56265       {
56266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56267       };
56268     }
56269   }
56270
56271 }
56272
56273
56274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56275   unsigned int jresult ;
56276   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56277   bool result;
56278
56279   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56280   {
56281     try {
56282       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56283     } catch (std::out_of_range& e) {
56284       {
56285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (std::exception& e) {
56288       {
56289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (Dali::DaliException e) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56294       };
56295     } catch (...) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56298       };
56299     }
56300   }
56301
56302   jresult = result;
56303   return jresult;
56304 }
56305
56306
56307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56308   unsigned long jresult ;
56309   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56310   std::size_t result;
56311
56312   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56313   {
56314     try {
56315       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56316     } catch (std::out_of_range& e) {
56317       {
56318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56319       };
56320     } catch (std::exception& e) {
56321       {
56322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56323       };
56324     } catch (Dali::DaliException e) {
56325       {
56326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56327       };
56328     } catch (...) {
56329       {
56330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56331       };
56332     }
56333   }
56334
56335   jresult = (unsigned long)result;
56336   return jresult;
56337 }
56338
56339
56340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56341   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56342   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56343
56344   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56345   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56346   {
56347     try {
56348       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56349     } catch (std::out_of_range& e) {
56350       {
56351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56352       };
56353     } catch (std::exception& e) {
56354       {
56355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56356       };
56357     } catch (Dali::DaliException e) {
56358       {
56359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56360       };
56361     } catch (...) {
56362       {
56363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56364       };
56365     }
56366   }
56367
56368 }
56369
56370
56371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56372   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56373   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56374
56375   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56376   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56377   {
56378     try {
56379       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56380     } catch (std::out_of_range& e) {
56381       {
56382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56383       };
56384     } catch (std::exception& e) {
56385       {
56386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56387       };
56388     } catch (Dali::DaliException e) {
56389       {
56390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56391       };
56392     } catch (...) {
56393       {
56394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56395       };
56396     }
56397   }
56398
56399 }
56400
56401
56402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56403   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56404   Dali::TouchData *arg2 = 0 ;
56405
56406   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56407   arg2 = (Dali::TouchData *)jarg2;
56408   if (!arg2) {
56409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56410     return ;
56411   }
56412   {
56413     try {
56414       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56415     } catch (std::out_of_range& e) {
56416       {
56417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56418       };
56419     } catch (std::exception& e) {
56420       {
56421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56422       };
56423     } catch (Dali::DaliException e) {
56424       {
56425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56426       };
56427     } catch (...) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56430       };
56431     }
56432   }
56433
56434 }
56435
56436
56437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56438   void * jresult ;
56439   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56440
56441   {
56442     try {
56443       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56444     } catch (std::out_of_range& e) {
56445       {
56446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56447       };
56448     } catch (std::exception& e) {
56449       {
56450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56451       };
56452     } catch (Dali::DaliException e) {
56453       {
56454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56455       };
56456     } catch (...) {
56457       {
56458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56459       };
56460     }
56461   }
56462
56463   jresult = (void *)result;
56464   return jresult;
56465 }
56466
56467
56468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56469   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56470
56471   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56472   {
56473     try {
56474       delete arg1;
56475     } catch (std::out_of_range& e) {
56476       {
56477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56478       };
56479     } catch (std::exception& e) {
56480       {
56481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56482       };
56483     } catch (Dali::DaliException e) {
56484       {
56485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56486       };
56487     } catch (...) {
56488       {
56489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56490       };
56491     }
56492   }
56493
56494 }
56495
56496
56497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56498   unsigned int jresult ;
56499   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56500   bool result;
56501
56502   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56503   {
56504     try {
56505       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56506     } catch (std::out_of_range& e) {
56507       {
56508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (std::exception& e) {
56511       {
56512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (Dali::DaliException e) {
56515       {
56516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56517       };
56518     } catch (...) {
56519       {
56520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56521       };
56522     }
56523   }
56524
56525   jresult = result;
56526   return jresult;
56527 }
56528
56529
56530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56531   unsigned long jresult ;
56532   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56533   std::size_t result;
56534
56535   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56536   {
56537     try {
56538       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56539     } catch (std::out_of_range& e) {
56540       {
56541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56542       };
56543     } catch (std::exception& e) {
56544       {
56545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56546       };
56547     } catch (Dali::DaliException e) {
56548       {
56549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56550       };
56551     } catch (...) {
56552       {
56553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56554       };
56555     }
56556   }
56557
56558   jresult = (unsigned long)result;
56559   return jresult;
56560 }
56561
56562
56563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56564   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56565   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56566
56567   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56568   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56569   {
56570     try {
56571       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56572     } catch (std::out_of_range& e) {
56573       {
56574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56575       };
56576     } catch (std::exception& e) {
56577       {
56578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56579       };
56580     } catch (Dali::DaliException e) {
56581       {
56582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56583       };
56584     } catch (...) {
56585       {
56586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56587       };
56588     }
56589   }
56590
56591 }
56592
56593
56594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56595   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56596   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56597
56598   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56599   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56600   {
56601     try {
56602       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56603     } catch (std::out_of_range& e) {
56604       {
56605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56606       };
56607     } catch (std::exception& e) {
56608       {
56609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56610       };
56611     } catch (Dali::DaliException e) {
56612       {
56613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56614       };
56615     } catch (...) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56618       };
56619     }
56620   }
56621
56622 }
56623
56624
56625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56626   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56627   Dali::WheelEvent *arg2 = 0 ;
56628
56629   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56630   arg2 = (Dali::WheelEvent *)jarg2;
56631   if (!arg2) {
56632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56633     return ;
56634   }
56635   {
56636     try {
56637       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56638     } catch (std::out_of_range& e) {
56639       {
56640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56641       };
56642     } catch (std::exception& e) {
56643       {
56644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56645       };
56646     } catch (Dali::DaliException e) {
56647       {
56648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56649       };
56650     } catch (...) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56653       };
56654     }
56655   }
56656
56657 }
56658
56659
56660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56661   void * jresult ;
56662   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56663
56664   {
56665     try {
56666       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56667     } catch (std::out_of_range& e) {
56668       {
56669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56670       };
56671     } catch (std::exception& e) {
56672       {
56673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56674       };
56675     } catch (Dali::DaliException e) {
56676       {
56677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56678       };
56679     } catch (...) {
56680       {
56681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56682       };
56683     }
56684   }
56685
56686   jresult = (void *)result;
56687   return jresult;
56688 }
56689
56690
56691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56692   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56693
56694   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56695   {
56696     try {
56697       delete arg1;
56698     } catch (std::out_of_range& e) {
56699       {
56700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56701       };
56702     } catch (std::exception& e) {
56703       {
56704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56705       };
56706     } catch (Dali::DaliException e) {
56707       {
56708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56709       };
56710     } catch (...) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56713       };
56714     }
56715   }
56716
56717 }
56718
56719
56720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56721   void * jresult ;
56722   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56723
56724   {
56725     try {
56726       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56727     } catch (std::out_of_range& e) {
56728       {
56729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56730       };
56731     } catch (std::exception& e) {
56732       {
56733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (Dali::DaliException e) {
56736       {
56737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56738       };
56739     } catch (...) {
56740       {
56741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56742       };
56743     }
56744   }
56745
56746   jresult = (void *)result;
56747   return jresult;
56748 }
56749
56750
56751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56752   void * jresult ;
56753   Dali::Radian arg1 ;
56754   Dali::Radian arg2 ;
56755   Dali::Radian *argp1 ;
56756   Dali::Radian *argp2 ;
56757   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56758
56759   argp1 = (Dali::Radian *)jarg1;
56760   if (!argp1) {
56761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56762     return 0;
56763   }
56764   arg1 = *argp1;
56765   argp2 = (Dali::Radian *)jarg2;
56766   if (!argp2) {
56767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56768     return 0;
56769   }
56770   arg2 = *argp2;
56771   {
56772     try {
56773       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56774     } catch (std::out_of_range& e) {
56775       {
56776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (std::exception& e) {
56779       {
56780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56781       };
56782     } catch (Dali::DaliException e) {
56783       {
56784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56785       };
56786     } catch (...) {
56787       {
56788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56789       };
56790     }
56791   }
56792
56793   jresult = (void *)result;
56794   return jresult;
56795 }
56796
56797
56798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56799   void * jresult ;
56800   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56801   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56802
56803   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56804   if (!arg1) {
56805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56806     return 0;
56807   }
56808   {
56809     try {
56810       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > 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 = (void *)result;
56831   return jresult;
56832 }
56833
56834
56835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56836   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56837   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56838
56839   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56840   arg2 = (Dali::Radian *)jarg2;
56841   if (arg1) (arg1)->first = *arg2;
56842 }
56843
56844
56845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56846   void * jresult ;
56847   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56848   Dali::Radian *result = 0 ;
56849
56850   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56851   result = (Dali::Radian *)& ((arg1)->first);
56852   jresult = (void *)result;
56853   return jresult;
56854 }
56855
56856
56857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56858   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56859   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56860
56861   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56862   arg2 = (Dali::Radian *)jarg2;
56863   if (arg1) (arg1)->second = *arg2;
56864 }
56865
56866
56867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
56868   void * jresult ;
56869   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56870   Dali::Radian *result = 0 ;
56871
56872   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56873   result = (Dali::Radian *)& ((arg1)->second);
56874   jresult = (void *)result;
56875   return jresult;
56876 }
56877
56878
56879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
56880   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56881
56882   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56883   {
56884     try {
56885       delete arg1;
56886     } catch (std::out_of_range& e) {
56887       {
56888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56889       };
56890     } catch (std::exception& e) {
56891       {
56892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56893       };
56894     } catch (Dali::DaliException e) {
56895       {
56896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56897       };
56898     } catch (...) {
56899       {
56900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56901       };
56902     }
56903   }
56904
56905 }
56906
56907
56908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
56909   unsigned int jresult ;
56910   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56911   bool result;
56912
56913   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56914   {
56915     try {
56916       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);
56917     } catch (std::out_of_range& e) {
56918       {
56919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (std::exception& e) {
56922       {
56923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56924       };
56925     } catch (Dali::DaliException e) {
56926       {
56927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56928       };
56929     } catch (...) {
56930       {
56931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56932       };
56933     }
56934   }
56935
56936   jresult = result;
56937   return jresult;
56938 }
56939
56940
56941 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56942   unsigned long jresult ;
56943   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56944   std::size_t result;
56945
56946   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56947   {
56948     try {
56949       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);
56950     } catch (std::out_of_range& e) {
56951       {
56952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56953       };
56954     } catch (std::exception& e) {
56955       {
56956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (Dali::DaliException e) {
56959       {
56960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56961       };
56962     } catch (...) {
56963       {
56964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56965       };
56966     }
56967   }
56968
56969   jresult = (unsigned long)result;
56970   return jresult;
56971 }
56972
56973
56974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56975   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56976   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
56977
56978   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56979   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
56980   {
56981     try {
56982       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56983     } catch (std::out_of_range& e) {
56984       {
56985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56986       };
56987     } catch (std::exception& e) {
56988       {
56989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56990       };
56991     } catch (Dali::DaliException e) {
56992       {
56993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56994       };
56995     } catch (...) {
56996       {
56997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56998       };
56999     }
57000   }
57001
57002 }
57003
57004
57005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57006   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57007   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57008
57009   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57010   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57011   {
57012     try {
57013       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57014     } catch (std::out_of_range& e) {
57015       {
57016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57017       };
57018     } catch (std::exception& e) {
57019       {
57020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57021       };
57022     } catch (Dali::DaliException e) {
57023       {
57024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57025       };
57026     } catch (...) {
57027       {
57028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57029       };
57030     }
57031   }
57032
57033 }
57034
57035
57036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57037   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57038   Dali::Actor arg2 ;
57039   Dali::PanGesture *arg3 = 0 ;
57040   Dali::Actor *argp2 ;
57041
57042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57043   argp2 = (Dali::Actor *)jarg2;
57044   if (!argp2) {
57045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57046     return ;
57047   }
57048   arg2 = *argp2;
57049   arg3 = (Dali::PanGesture *)jarg3;
57050   if (!arg3) {
57051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57052     return ;
57053   }
57054   {
57055     try {
57056       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57057     } catch (std::out_of_range& e) {
57058       {
57059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57060       };
57061     } catch (std::exception& e) {
57062       {
57063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57064       };
57065     } catch (Dali::DaliException e) {
57066       {
57067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57068       };
57069     } catch (...) {
57070       {
57071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57072       };
57073     }
57074   }
57075
57076 }
57077
57078
57079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57080   void * jresult ;
57081   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57082
57083   {
57084     try {
57085       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57086     } catch (std::out_of_range& e) {
57087       {
57088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (std::exception& e) {
57091       {
57092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57093       };
57094     } catch (Dali::DaliException e) {
57095       {
57096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57097       };
57098     } catch (...) {
57099       {
57100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57101       };
57102     }
57103   }
57104
57105   jresult = (void *)result;
57106   return jresult;
57107 }
57108
57109
57110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57111   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57112
57113   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57114   {
57115     try {
57116       delete arg1;
57117     } catch (std::out_of_range& e) {
57118       {
57119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57120       };
57121     } catch (std::exception& e) {
57122       {
57123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57124       };
57125     } catch (Dali::DaliException e) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57128       };
57129     } catch (...) {
57130       {
57131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57132       };
57133     }
57134   }
57135
57136 }
57137
57138
57139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57140   unsigned int jresult ;
57141   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57142   bool result;
57143
57144   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57145   {
57146     try {
57147       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);
57148     } catch (std::out_of_range& e) {
57149       {
57150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (std::exception& e) {
57153       {
57154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57155       };
57156     } catch (Dali::DaliException e) {
57157       {
57158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57159       };
57160     } catch (...) {
57161       {
57162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57163       };
57164     }
57165   }
57166
57167   jresult = result;
57168   return jresult;
57169 }
57170
57171
57172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57173   unsigned long jresult ;
57174   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57175   std::size_t result;
57176
57177   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57178   {
57179     try {
57180       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);
57181     } catch (std::out_of_range& e) {
57182       {
57183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57184       };
57185     } catch (std::exception& e) {
57186       {
57187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57188       };
57189     } catch (Dali::DaliException e) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57192       };
57193     } catch (...) {
57194       {
57195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57196       };
57197     }
57198   }
57199
57200   jresult = (unsigned long)result;
57201   return jresult;
57202 }
57203
57204
57205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57206   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57207   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57208
57209   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57210   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57211   {
57212     try {
57213       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57214     } catch (std::out_of_range& e) {
57215       {
57216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57217       };
57218     } catch (std::exception& e) {
57219       {
57220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57221       };
57222     } catch (Dali::DaliException e) {
57223       {
57224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57225       };
57226     } catch (...) {
57227       {
57228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57229       };
57230     }
57231   }
57232
57233 }
57234
57235
57236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57237   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57238   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57239
57240   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57241   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57242   {
57243     try {
57244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57245     } catch (std::out_of_range& e) {
57246       {
57247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57248       };
57249     } catch (std::exception& e) {
57250       {
57251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57252       };
57253     } catch (Dali::DaliException e) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57256       };
57257     } catch (...) {
57258       {
57259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57260       };
57261     }
57262   }
57263
57264 }
57265
57266
57267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57268   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57269   Dali::Actor arg2 ;
57270   Dali::PinchGesture *arg3 = 0 ;
57271   Dali::Actor *argp2 ;
57272
57273   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57274   argp2 = (Dali::Actor *)jarg2;
57275   if (!argp2) {
57276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57277     return ;
57278   }
57279   arg2 = *argp2;
57280   arg3 = (Dali::PinchGesture *)jarg3;
57281   if (!arg3) {
57282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57283     return ;
57284   }
57285   {
57286     try {
57287       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
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_new_PinchGestureDetectedSignal() {
57311   void * jresult ;
57312   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57313
57314   {
57315     try {
57316       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57317     } catch (std::out_of_range& e) {
57318       {
57319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (std::exception& e) {
57322       {
57323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (Dali::DaliException e) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57328       };
57329     } catch (...) {
57330       {
57331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57332       };
57333     }
57334   }
57335
57336   jresult = (void *)result;
57337   return jresult;
57338 }
57339
57340
57341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57342   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57343
57344   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57345   {
57346     try {
57347       delete arg1;
57348     } catch (std::out_of_range& e) {
57349       {
57350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57351       };
57352     } catch (std::exception& e) {
57353       {
57354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57355       };
57356     } catch (Dali::DaliException e) {
57357       {
57358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57359       };
57360     } catch (...) {
57361       {
57362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57363       };
57364     }
57365   }
57366
57367 }
57368
57369
57370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57371   unsigned int jresult ;
57372   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57373   bool result;
57374
57375   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57376   {
57377     try {
57378       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);
57379     } catch (std::out_of_range& e) {
57380       {
57381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57382       };
57383     } catch (std::exception& e) {
57384       {
57385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57386       };
57387     } catch (Dali::DaliException e) {
57388       {
57389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57390       };
57391     } catch (...) {
57392       {
57393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57394       };
57395     }
57396   }
57397
57398   jresult = result;
57399   return jresult;
57400 }
57401
57402
57403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57404   unsigned long jresult ;
57405   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57406   std::size_t result;
57407
57408   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57409   {
57410     try {
57411       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);
57412     } catch (std::out_of_range& e) {
57413       {
57414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57415       };
57416     } catch (std::exception& e) {
57417       {
57418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57419       };
57420     } catch (Dali::DaliException e) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57423       };
57424     } catch (...) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57427       };
57428     }
57429   }
57430
57431   jresult = (unsigned long)result;
57432   return jresult;
57433 }
57434
57435
57436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57437   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57438   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57439
57440   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57441   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57442   {
57443     try {
57444       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57445     } catch (std::out_of_range& e) {
57446       {
57447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57448       };
57449     } catch (std::exception& e) {
57450       {
57451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57452       };
57453     } catch (Dali::DaliException e) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57456       };
57457     } catch (...) {
57458       {
57459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57460       };
57461     }
57462   }
57463
57464 }
57465
57466
57467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57468   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57469   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57470
57471   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57472   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57473   {
57474     try {
57475       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57476     } catch (std::out_of_range& e) {
57477       {
57478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57479       };
57480     } catch (std::exception& e) {
57481       {
57482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57483       };
57484     } catch (Dali::DaliException e) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57487       };
57488     } catch (...) {
57489       {
57490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57491       };
57492     }
57493   }
57494
57495 }
57496
57497
57498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57499   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57500   Dali::Actor arg2 ;
57501   Dali::TapGesture *arg3 = 0 ;
57502   Dali::Actor *argp2 ;
57503
57504   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57505   argp2 = (Dali::Actor *)jarg2;
57506   if (!argp2) {
57507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57508     return ;
57509   }
57510   arg2 = *argp2;
57511   arg3 = (Dali::TapGesture *)jarg3;
57512   if (!arg3) {
57513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57514     return ;
57515   }
57516   {
57517     try {
57518       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
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_new_TapGestureDetectedSignal() {
57542   void * jresult ;
57543   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57544
57545   {
57546     try {
57547       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57548     } catch (std::out_of_range& e) {
57549       {
57550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57551       };
57552     } catch (std::exception& e) {
57553       {
57554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57555       };
57556     } catch (Dali::DaliException e) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57559       };
57560     } catch (...) {
57561       {
57562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57563       };
57564     }
57565   }
57566
57567   jresult = (void *)result;
57568   return jresult;
57569 }
57570
57571
57572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57573   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57574
57575   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57576   {
57577     try {
57578       delete arg1;
57579     } catch (std::out_of_range& e) {
57580       {
57581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57582       };
57583     } catch (std::exception& e) {
57584       {
57585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57586       };
57587     } catch (Dali::DaliException e) {
57588       {
57589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57590       };
57591     } catch (...) {
57592       {
57593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57594       };
57595     }
57596   }
57597
57598 }
57599
57600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57601   unsigned int jresult ;
57602   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57603   bool result;
57604
57605   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57606   {
57607     try {
57608       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57609     } catch (std::out_of_range& e) {
57610       {
57611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57612       };
57613     } catch (std::exception& e) {
57614       {
57615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57616       };
57617     } catch (Dali::DaliException e) {
57618       {
57619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57620       };
57621     } catch (...) {
57622       {
57623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57624       };
57625     }
57626   }
57627
57628   jresult = result;
57629   return jresult;
57630 }
57631
57632
57633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57634   unsigned long jresult ;
57635   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57636   std::size_t result;
57637
57638   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57639   {
57640     try {
57641       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57642     } catch (std::out_of_range& e) {
57643       {
57644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57645       };
57646     } catch (std::exception& e) {
57647       {
57648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57649       };
57650     } catch (Dali::DaliException e) {
57651       {
57652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57653       };
57654     } catch (...) {
57655       {
57656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57657       };
57658     }
57659   }
57660
57661   jresult = (unsigned long)result;
57662   return jresult;
57663 }
57664
57665
57666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57667   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57668   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57669
57670   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57671   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57672   {
57673     try {
57674       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57675     } catch (std::out_of_range& e) {
57676       {
57677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57678       };
57679     } catch (std::exception& e) {
57680       {
57681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57682       };
57683     } catch (Dali::DaliException e) {
57684       {
57685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57686       };
57687     } catch (...) {
57688       {
57689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57690       };
57691     }
57692   }
57693
57694 }
57695
57696
57697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57698   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57699   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57700
57701   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57702   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57703   {
57704     try {
57705       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57706     } catch (std::out_of_range& e) {
57707       {
57708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57709       };
57710     } catch (std::exception& e) {
57711       {
57712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57713       };
57714     } catch (Dali::DaliException e) {
57715       {
57716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57717       };
57718     } catch (...) {
57719       {
57720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57721       };
57722     }
57723   }
57724
57725 }
57726
57727
57728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57729   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57730   Dali::ResourceImage arg2 ;
57731   Dali::ResourceImage *argp2 ;
57732
57733   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57734   argp2 = (Dali::ResourceImage *)jarg2;
57735   if (!argp2) {
57736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57737     return ;
57738   }
57739   arg2 = *argp2;
57740   {
57741     try {
57742       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57743     } catch (std::out_of_range& e) {
57744       {
57745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57746       };
57747     } catch (std::exception& e) {
57748       {
57749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57750       };
57751     } catch (Dali::DaliException e) {
57752       {
57753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57754       };
57755     } catch (...) {
57756       {
57757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57758       };
57759     }
57760   }
57761
57762 }
57763
57764
57765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57766   void * jresult ;
57767   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57768
57769   {
57770     try {
57771       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57772     } catch (std::out_of_range& e) {
57773       {
57774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57775       };
57776     } catch (std::exception& e) {
57777       {
57778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57779       };
57780     } catch (Dali::DaliException e) {
57781       {
57782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57783       };
57784     } catch (...) {
57785       {
57786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57787       };
57788     }
57789   }
57790
57791   jresult = (void *)result;
57792   return jresult;
57793 }
57794
57795
57796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57797   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57798
57799   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57800   {
57801     try {
57802       delete arg1;
57803     } catch (std::out_of_range& e) {
57804       {
57805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57806       };
57807     } catch (std::exception& e) {
57808       {
57809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57810       };
57811     } catch (Dali::DaliException e) {
57812       {
57813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57814       };
57815     } catch (...) {
57816       {
57817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57818       };
57819     }
57820   }
57821
57822 }
57823
57824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57825   unsigned int jresult ;
57826   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57827   bool result = false;
57828
57829   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57830   {
57831     try {
57832       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);
57833     } catch (std::out_of_range& e) {
57834       {
57835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57836       };
57837     } catch (std::exception& e) {
57838       {
57839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57840       };
57841     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57842   }
57843   jresult = result;
57844   return jresult;
57845 }
57846
57847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57848   unsigned long jresult ;
57849   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57850   std::size_t result = 0;
57851
57852   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57853   {
57854     try {
57855       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);
57856     } catch (std::out_of_range& e) {
57857       {
57858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57859       };
57860     } catch (std::exception& e) {
57861       {
57862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57863       };
57864     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57865   }
57866   jresult = (unsigned long)result;
57867   return jresult;
57868 }
57869
57870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
57871   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57872   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57873
57874   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57875   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57876   {
57877     try {
57878       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
57879     } catch (std::out_of_range& e) {
57880       {
57881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57882       };
57883     } catch (std::exception& e) {
57884       {
57885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57886       };
57887     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57888   }
57889 }
57890
57891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
57892   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57893   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
57894
57895   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57896   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
57897   {
57898     try {
57899       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
57900     } catch (std::out_of_range& e) {
57901       {
57902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57903       };
57904     } catch (std::exception& e) {
57905       {
57906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57907       };
57908     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57909   }
57910 }
57911
57912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
57913   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57914   Dali::Actor arg2 ;
57915   //bool arg3 ;
57916   Dali::LayoutDirection::Type arg4 ;
57917   Dali::Actor *argp2 ;
57918
57919   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57920   argp2 = (Dali::Actor *)jarg2;
57921   if (!argp2) {
57922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57923     return ;
57924   }
57925   arg2 = *argp2;
57926   //arg3 = jarg3 ? true : false;
57927   arg4 = (Dali::LayoutDirection::Type)jarg4;
57928   {
57929     try {
57930       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
57931     } catch (std::out_of_range& e) {
57932       {
57933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57934       };
57935     } catch (std::exception& e) {
57936       {
57937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57938       };
57939     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57940   }
57941 }
57942
57943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
57944   void * jresult ;
57945   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
57946
57947   {
57948     try {
57949       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
57950     } catch (std::out_of_range& e) {
57951       {
57952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57953       };
57954     } catch (std::exception& e) {
57955       {
57956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57957       };
57958     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57959   }
57960   jresult = (void *)result;
57961   return jresult;
57962 }
57963
57964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
57965   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57966
57967   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57968   {
57969     try {
57970       delete arg1;
57971     } catch (std::out_of_range& e) {
57972       {
57973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57974       };
57975     } catch (std::exception& e) {
57976       {
57977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57978       };
57979     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57980   }
57981 }
57982
57983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
57984   unsigned int jresult ;
57985   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57986   bool result;
57987
57988   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57989   {
57990     try {
57991       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);
57992     } catch (std::out_of_range& e) {
57993       {
57994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (std::exception& e) {
57997       {
57998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57999       };
58000     } catch (Dali::DaliException e) {
58001       {
58002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58003       };
58004     } catch (...) {
58005       {
58006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58007       };
58008     }
58009   }
58010
58011   jresult = result;
58012   return jresult;
58013 }
58014
58015
58016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58017   unsigned long jresult ;
58018   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58019   std::size_t result;
58020
58021   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58022   {
58023     try {
58024       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);
58025     } catch (std::out_of_range& e) {
58026       {
58027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58028       };
58029     } catch (std::exception& e) {
58030       {
58031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58032       };
58033     } catch (Dali::DaliException e) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58036       };
58037     } catch (...) {
58038       {
58039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58040       };
58041     }
58042   }
58043
58044   jresult = (unsigned long)result;
58045   return jresult;
58046 }
58047
58048
58049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58050   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58051   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58052
58053   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58054   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58055   {
58056     try {
58057       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58058     } catch (std::out_of_range& e) {
58059       {
58060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58061       };
58062     } catch (std::exception& e) {
58063       {
58064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58065       };
58066     } catch (Dali::DaliException e) {
58067       {
58068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58069       };
58070     } catch (...) {
58071       {
58072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58073       };
58074     }
58075   }
58076
58077 }
58078
58079
58080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58081   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58082   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58083
58084   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58085   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58086   {
58087     try {
58088       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58096       };
58097     } catch (Dali::DaliException e) {
58098       {
58099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58100       };
58101     } catch (...) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58104       };
58105     }
58106   }
58107
58108 }
58109
58110
58111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58112   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58113   Dali::Actor arg2 ;
58114   bool arg3 ;
58115   Dali::DevelActor::VisibilityChange::Type arg4 ;
58116   Dali::Actor *argp2 ;
58117
58118   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58119   argp2 = (Dali::Actor *)jarg2;
58120   if (!argp2) {
58121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58122     return ;
58123   }
58124   arg2 = *argp2;
58125   arg3 = jarg3 ? true : false;
58126   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58127   {
58128     try {
58129       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58130     } catch (std::out_of_range& e) {
58131       {
58132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58133       };
58134     } catch (std::exception& e) {
58135       {
58136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58137       };
58138     } catch (Dali::DaliException e) {
58139       {
58140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58141       };
58142     } catch (...) {
58143       {
58144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58145       };
58146     }
58147   }
58148
58149 }
58150
58151
58152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58153   void * jresult ;
58154   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58155
58156   {
58157     try {
58158       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58159     } catch (std::out_of_range& e) {
58160       {
58161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58162       };
58163     } catch (std::exception& e) {
58164       {
58165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58166       };
58167     } catch (Dali::DaliException e) {
58168       {
58169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58170       };
58171     } catch (...) {
58172       {
58173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58174       };
58175     }
58176   }
58177
58178   jresult = (void *)result;
58179   return jresult;
58180 }
58181
58182
58183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58184   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58185
58186   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58187   {
58188     try {
58189       delete arg1;
58190     } catch (std::out_of_range& e) {
58191       {
58192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58193       };
58194     } catch (std::exception& e) {
58195       {
58196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58197       };
58198     } catch (Dali::DaliException e) {
58199       {
58200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58201       };
58202     } catch (...) {
58203       {
58204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58205       };
58206     }
58207   }
58208
58209 }
58210
58211
58212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58213   void * jresult ;
58214   Dali::Timer *result = 0 ;
58215
58216   {
58217     try {
58218       result = (Dali::Timer *)new Dali::Timer();
58219     } catch (std::out_of_range& e) {
58220       {
58221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (std::exception& e) {
58224       {
58225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58226       };
58227     } catch (Dali::DaliException e) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58230       };
58231     } catch (...) {
58232       {
58233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58234       };
58235     }
58236   }
58237
58238   jresult = (void *)result;
58239   return jresult;
58240 }
58241
58242
58243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58244   void * jresult ;
58245   unsigned int arg1 ;
58246   Dali::Timer result;
58247
58248   arg1 = (unsigned int)jarg1;
58249   {
58250     try {
58251       result = Dali::Timer::New(arg1);
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (Dali::DaliException e) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58263       };
58264     } catch (...) {
58265       {
58266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58267       };
58268     }
58269   }
58270
58271   jresult = new Dali::Timer((const Dali::Timer &)result);
58272   return jresult;
58273 }
58274
58275
58276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58277   void * jresult ;
58278   Dali::Timer *arg1 = 0 ;
58279   Dali::Timer *result = 0 ;
58280
58281   arg1 = (Dali::Timer *)jarg1;
58282   if (!arg1) {
58283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58284     return 0;
58285   }
58286   {
58287     try {
58288       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58289     } catch (std::out_of_range& e) {
58290       {
58291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58292       };
58293     } catch (std::exception& e) {
58294       {
58295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58296       };
58297     } catch (Dali::DaliException e) {
58298       {
58299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58300       };
58301     } catch (...) {
58302       {
58303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58304       };
58305     }
58306   }
58307
58308   jresult = (void *)result;
58309   return jresult;
58310 }
58311
58312
58313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58314   void * jresult ;
58315   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58316   Dali::Timer *arg2 = 0 ;
58317   Dali::Timer *result = 0 ;
58318
58319   arg1 = (Dali::Timer *)jarg1;
58320   arg2 = (Dali::Timer *)jarg2;
58321   if (!arg2) {
58322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58323     return 0;
58324   }
58325   {
58326     try {
58327       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58328     } catch (std::out_of_range& e) {
58329       {
58330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58331       };
58332     } catch (std::exception& e) {
58333       {
58334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58335       };
58336     } catch (Dali::DaliException e) {
58337       {
58338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58339       };
58340     } catch (...) {
58341       {
58342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58343       };
58344     }
58345   }
58346
58347   jresult = (void *)result;
58348   return jresult;
58349 }
58350
58351
58352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58353   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58354
58355   arg1 = (Dali::Timer *)jarg1;
58356   {
58357     try {
58358       delete arg1;
58359     } catch (std::out_of_range& e) {
58360       {
58361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58362       };
58363     } catch (std::exception& e) {
58364       {
58365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58366       };
58367     } catch (Dali::DaliException e) {
58368       {
58369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58370       };
58371     } catch (...) {
58372       {
58373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58374       };
58375     }
58376   }
58377
58378 }
58379
58380
58381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58382   void * jresult ;
58383   Dali::BaseHandle arg1 ;
58384   Dali::BaseHandle *argp1 ;
58385   Dali::Timer result;
58386
58387   argp1 = (Dali::BaseHandle *)jarg1;
58388   if (!argp1) {
58389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58390     return 0;
58391   }
58392   arg1 = *argp1;
58393   {
58394     try {
58395       result = Dali::Timer::DownCast(arg1);
58396     } catch (std::out_of_range& e) {
58397       {
58398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58399       };
58400     } catch (std::exception& e) {
58401       {
58402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58403       };
58404     } catch (Dali::DaliException e) {
58405       {
58406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58407       };
58408     } catch (...) {
58409       {
58410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58411       };
58412     }
58413   }
58414
58415   jresult = new Dali::Timer((const Dali::Timer &)result);
58416   return jresult;
58417 }
58418
58419
58420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58421   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58422
58423   arg1 = (Dali::Timer *)jarg1;
58424   {
58425     try {
58426       (arg1)->Start();
58427     } catch (std::out_of_range& e) {
58428       {
58429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58430       };
58431     } catch (std::exception& e) {
58432       {
58433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58434       };
58435     } catch (Dali::DaliException e) {
58436       {
58437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58438       };
58439     } catch (...) {
58440       {
58441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58442       };
58443     }
58444   }
58445
58446 }
58447
58448
58449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58450   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58451
58452   arg1 = (Dali::Timer *)jarg1;
58453   {
58454     try {
58455       (arg1)->Stop();
58456     } catch (std::out_of_range& e) {
58457       {
58458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58459       };
58460     } catch (std::exception& e) {
58461       {
58462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58463       };
58464     } catch (Dali::DaliException e) {
58465       {
58466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58467       };
58468     } catch (...) {
58469       {
58470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58471       };
58472     }
58473   }
58474
58475 }
58476
58477
58478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58479   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58480   unsigned int arg2 ;
58481
58482   arg1 = (Dali::Timer *)jarg1;
58483   arg2 = (unsigned int)jarg2;
58484   {
58485     try {
58486       (arg1)->SetInterval(arg2);
58487     } catch (std::out_of_range& e) {
58488       {
58489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58490       };
58491     } catch (std::exception& e) {
58492       {
58493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58494       };
58495     } catch (Dali::DaliException e) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58498       };
58499     } catch (...) {
58500       {
58501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58502       };
58503     }
58504   }
58505
58506 }
58507
58508
58509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58510   unsigned int jresult ;
58511   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58512   unsigned int result;
58513
58514   arg1 = (Dali::Timer *)jarg1;
58515   {
58516     try {
58517       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58518     } catch (std::out_of_range& e) {
58519       {
58520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58521       };
58522     } catch (std::exception& e) {
58523       {
58524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58525       };
58526     } catch (Dali::DaliException e) {
58527       {
58528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58529       };
58530     } catch (...) {
58531       {
58532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58533       };
58534     }
58535   }
58536
58537   jresult = result;
58538   return jresult;
58539 }
58540
58541
58542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58543   unsigned int jresult ;
58544   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58545   bool result;
58546
58547   arg1 = (Dali::Timer *)jarg1;
58548   {
58549     try {
58550       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58551     } catch (std::out_of_range& e) {
58552       {
58553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58554       };
58555     } catch (std::exception& e) {
58556       {
58557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58558       };
58559     } catch (Dali::DaliException e) {
58560       {
58561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58562       };
58563     } catch (...) {
58564       {
58565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58566       };
58567     }
58568   }
58569
58570   jresult = result;
58571   return jresult;
58572 }
58573
58574
58575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58576   void * jresult ;
58577   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58578   Dali::Timer::TimerSignalType *result = 0 ;
58579
58580   arg1 = (Dali::Timer *)jarg1;
58581   {
58582     try {
58583       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58584     } catch (std::out_of_range& e) {
58585       {
58586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58587       };
58588     } catch (std::exception& e) {
58589       {
58590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58591       };
58592     } catch (Dali::DaliException e) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58595       };
58596     } catch (...) {
58597       {
58598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58599       };
58600     }
58601   }
58602
58603   jresult = (void *)result;
58604   return jresult;
58605 }
58606
58607
58608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58609   unsigned int jresult ;
58610   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58611   bool result;
58612
58613   arg1 = (Dali::Signal< bool () > *)jarg1;
58614   {
58615     try {
58616       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58617     } catch (std::out_of_range& e) {
58618       {
58619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58620       };
58621     } catch (std::exception& e) {
58622       {
58623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58624       };
58625     } catch (Dali::DaliException e) {
58626       {
58627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58628       };
58629     } catch (...) {
58630       {
58631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58632       };
58633     }
58634   }
58635
58636   jresult = result;
58637   return jresult;
58638 }
58639
58640
58641 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58642   unsigned long jresult ;
58643   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58644   std::size_t result;
58645
58646   arg1 = (Dali::Signal< bool () > *)jarg1;
58647   {
58648     try {
58649       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58650     } catch (std::out_of_range& e) {
58651       {
58652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58653       };
58654     } catch (std::exception& e) {
58655       {
58656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58657       };
58658     } catch (Dali::DaliException e) {
58659       {
58660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58661       };
58662     } catch (...) {
58663       {
58664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58665       };
58666     }
58667   }
58668
58669   jresult = (unsigned long)result;
58670   return jresult;
58671 }
58672
58673
58674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58675   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58676   bool (*arg2)() = (bool (*)()) 0 ;
58677
58678   arg1 = (Dali::Signal< bool () > *)jarg1;
58679   arg2 = (bool (*)())jarg2;
58680   {
58681     try {
58682       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58683     } catch (std::out_of_range& e) {
58684       {
58685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58686       };
58687     } catch (std::exception& e) {
58688       {
58689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58690       };
58691     } catch (Dali::DaliException e) {
58692       {
58693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58694       };
58695     } catch (...) {
58696       {
58697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58698       };
58699     }
58700   }
58701
58702 }
58703
58704
58705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58706   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58707   bool (*arg2)() = (bool (*)()) 0 ;
58708
58709   arg1 = (Dali::Signal< bool () > *)jarg1;
58710   arg2 = (bool (*)())jarg2;
58711   {
58712     try {
58713       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58714     } catch (std::out_of_range& e) {
58715       {
58716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58717       };
58718     } catch (std::exception& e) {
58719       {
58720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58721       };
58722     } catch (Dali::DaliException e) {
58723       {
58724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58725       };
58726     } catch (...) {
58727       {
58728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58729       };
58730     }
58731   }
58732
58733 }
58734
58735
58736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58737   unsigned int jresult ;
58738   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58739   bool result;
58740
58741   arg1 = (Dali::Signal< bool () > *)jarg1;
58742   {
58743     try {
58744       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58745     } catch (std::out_of_range& e) {
58746       {
58747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58748       };
58749     } catch (std::exception& e) {
58750       {
58751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58752       };
58753     } catch (Dali::DaliException e) {
58754       {
58755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58756       };
58757     } catch (...) {
58758       {
58759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58760       };
58761     }
58762   }
58763
58764   jresult = result;
58765   return jresult;
58766 }
58767
58768
58769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58770   void * jresult ;
58771   Dali::Signal< bool () > *result = 0 ;
58772
58773   {
58774     try {
58775       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
58776     } catch (std::out_of_range& e) {
58777       {
58778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58779       };
58780     } catch (std::exception& e) {
58781       {
58782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58783       };
58784     } catch (Dali::DaliException e) {
58785       {
58786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58787       };
58788     } catch (...) {
58789       {
58790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58791       };
58792     }
58793   }
58794
58795   jresult = (void *)result;
58796   return jresult;
58797 }
58798
58799
58800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
58801   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58802
58803   arg1 = (Dali::Signal< bool () > *)jarg1;
58804   {
58805     try {
58806       delete arg1;
58807     } catch (std::out_of_range& e) {
58808       {
58809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58810       };
58811     } catch (std::exception& e) {
58812       {
58813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58814       };
58815     } catch (Dali::DaliException e) {
58816       {
58817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58818       };
58819     } catch (...) {
58820       {
58821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58822       };
58823     }
58824   }
58825
58826 }
58827
58828
58829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
58830   int jresult ;
58831   int result;
58832
58833   {
58834     try {
58835       result = (int)Dali::Toolkit::Visual::Property::TYPE;
58836     } catch (std::out_of_range& e) {
58837       {
58838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58839       };
58840     } catch (std::exception& e) {
58841       {
58842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58843       };
58844     } catch (Dali::DaliException e) {
58845       {
58846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58847       };
58848     } catch (...) {
58849       {
58850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58851       };
58852     }
58853   }
58854
58855   jresult = (int)result;
58856   return jresult;
58857 }
58858
58859
58860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
58861   int jresult ;
58862   int result;
58863
58864   {
58865     try {
58866       result = (int)Dali::Toolkit::Visual::Property::SHADER;
58867     } catch (std::out_of_range& e) {
58868       {
58869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58870       };
58871     } catch (std::exception& e) {
58872       {
58873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58874       };
58875     } catch (Dali::DaliException e) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58878       };
58879     } catch (...) {
58880       {
58881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58882       };
58883     }
58884   }
58885
58886   jresult = (int)result;
58887   return jresult;
58888 }
58889
58890
58891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
58892   int jresult ;
58893   int result;
58894
58895   {
58896     try {
58897       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
58898     } catch (std::out_of_range& e) {
58899       {
58900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58901       };
58902     } catch (std::exception& e) {
58903       {
58904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58905       };
58906     } catch (Dali::DaliException e) {
58907       {
58908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58909       };
58910     } catch (...) {
58911       {
58912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58913       };
58914     }
58915   }
58916
58917   jresult = (int)result;
58918   return jresult;
58919 }
58920
58921
58922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
58923   int jresult ;
58924   int result;
58925
58926   {
58927     try {
58928       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
58929     } catch (std::out_of_range& e) {
58930       {
58931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58932       };
58933     } catch (std::exception& e) {
58934       {
58935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58936       };
58937     } catch (Dali::DaliException e) {
58938       {
58939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58940       };
58941     } catch (...) {
58942       {
58943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58944       };
58945     }
58946   }
58947
58948   jresult = (int)result;
58949   return jresult;
58950 }
58951
58952
58953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
58954   int jresult ;
58955   int result;
58956
58957   {
58958     try {
58959       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
58960     } catch (std::out_of_range& e) {
58961       {
58962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58963       };
58964     } catch (std::exception& e) {
58965       {
58966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58967       };
58968     } catch (Dali::DaliException e) {
58969       {
58970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58971       };
58972     } catch (...) {
58973       {
58974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58975       };
58976     }
58977   }
58978
58979   jresult = (int)result;
58980   return jresult;
58981 }
58982
58983
58984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
58985   int jresult ;
58986   int result;
58987
58988   {
58989     try {
58990       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
58991     } catch (std::out_of_range& e) {
58992       {
58993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58994       };
58995     } catch (std::exception& e) {
58996       {
58997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58998       };
58999     } catch (Dali::DaliException e) {
59000       {
59001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59002       };
59003     } catch (...) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59006       };
59007     }
59008   }
59009
59010   jresult = (int)result;
59011   return jresult;
59012 }
59013
59014
59015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59016   int jresult ;
59017   int result;
59018
59019   {
59020     try {
59021       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59022     } catch (std::out_of_range& e) {
59023       {
59024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59025       };
59026     } catch (std::exception& e) {
59027       {
59028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59029       };
59030     } catch (Dali::DaliException e) {
59031       {
59032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59033       };
59034     } catch (...) {
59035       {
59036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59037       };
59038     }
59039   }
59040
59041   jresult = (int)result;
59042   return jresult;
59043 }
59044
59045
59046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59047   int jresult ;
59048   int result;
59049
59050   {
59051     try {
59052       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59053     } catch (std::out_of_range& e) {
59054       {
59055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59056       };
59057     } catch (std::exception& e) {
59058       {
59059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59060       };
59061     } catch (Dali::DaliException e) {
59062       {
59063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59064       };
59065     } catch (...) {
59066       {
59067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59068       };
59069     }
59070   }
59071
59072   jresult = (int)result;
59073   return jresult;
59074 }
59075
59076
59077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59078   int jresult ;
59079   int result;
59080
59081   {
59082     try {
59083       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59084     } catch (std::out_of_range& e) {
59085       {
59086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59087       };
59088     } catch (std::exception& e) {
59089       {
59090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59091       };
59092     } catch (Dali::DaliException e) {
59093       {
59094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59095       };
59096     } catch (...) {
59097       {
59098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59099       };
59100     }
59101   }
59102
59103   jresult = (int)result;
59104   return jresult;
59105 }
59106
59107
59108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59109   int jresult ;
59110   int result;
59111
59112   {
59113     try {
59114       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59115     } catch (std::out_of_range& e) {
59116       {
59117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59118       };
59119     } catch (std::exception& e) {
59120       {
59121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59122       };
59123     } catch (Dali::DaliException e) {
59124       {
59125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59126       };
59127     } catch (...) {
59128       {
59129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59130       };
59131     }
59132   }
59133
59134   jresult = (int)result;
59135   return jresult;
59136 }
59137
59138
59139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59140   int jresult ;
59141   int result;
59142
59143   {
59144     try {
59145       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59146     } catch (std::out_of_range& e) {
59147       {
59148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59149       };
59150     } catch (std::exception& e) {
59151       {
59152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59153       };
59154     } catch (Dali::DaliException e) {
59155       {
59156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59157       };
59158     } catch (...) {
59159       {
59160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59161       };
59162     }
59163   }
59164
59165   jresult = (int)result;
59166   return jresult;
59167 }
59168
59169
59170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59171   int jresult ;
59172   int result;
59173
59174   {
59175     try {
59176       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59177     } catch (std::out_of_range& e) {
59178       {
59179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59180       };
59181     } catch (std::exception& e) {
59182       {
59183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59184       };
59185     } catch (Dali::DaliException e) {
59186       {
59187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59188       };
59189     } catch (...) {
59190       {
59191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59192       };
59193     }
59194   }
59195
59196   jresult = (int)result;
59197   return jresult;
59198 }
59199
59200
59201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59202   int jresult ;
59203   int result;
59204
59205   {
59206     try {
59207       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59208     } catch (std::out_of_range& e) {
59209       {
59210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59211       };
59212     } catch (std::exception& e) {
59213       {
59214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59215       };
59216     } catch (Dali::DaliException e) {
59217       {
59218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59219       };
59220     } catch (...) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59223       };
59224     }
59225   }
59226
59227   jresult = (int)result;
59228   return jresult;
59229 }
59230
59231
59232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59233   int jresult ;
59234   int result;
59235
59236   {
59237     try {
59238       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59239     } catch (std::out_of_range& e) {
59240       {
59241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59242       };
59243     } catch (std::exception& e) {
59244       {
59245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59246       };
59247     } catch (Dali::DaliException e) {
59248       {
59249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59250       };
59251     } catch (...) {
59252       {
59253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59254       };
59255     }
59256   }
59257
59258   jresult = (int)result;
59259   return jresult;
59260 }
59261
59262
59263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59264   int jresult ;
59265   int result;
59266
59267   {
59268     try {
59269       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59270     } catch (std::out_of_range& e) {
59271       {
59272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59273       };
59274     } catch (std::exception& e) {
59275       {
59276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59277       };
59278     } catch (Dali::DaliException e) {
59279       {
59280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59281       };
59282     } catch (...) {
59283       {
59284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59285       };
59286     }
59287   }
59288
59289   jresult = (int)result;
59290   return jresult;
59291 }
59292
59293
59294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59295   int jresult ;
59296   int result;
59297
59298   {
59299     try {
59300       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59301     } catch (std::out_of_range& e) {
59302       {
59303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59304       };
59305     } catch (std::exception& e) {
59306       {
59307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59308       };
59309     } catch (Dali::DaliException e) {
59310       {
59311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59312       };
59313     } catch (...) {
59314       {
59315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59316       };
59317     }
59318   }
59319
59320   jresult = (int)result;
59321   return jresult;
59322 }
59323
59324
59325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59326   int jresult ;
59327   int result;
59328
59329   {
59330     try {
59331       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59332     } catch (std::out_of_range& e) {
59333       {
59334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59335       };
59336     } catch (std::exception& e) {
59337       {
59338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (Dali::DaliException e) {
59341       {
59342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59343       };
59344     } catch (...) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59347       };
59348     }
59349   }
59350
59351   jresult = (int)result;
59352   return jresult;
59353 }
59354
59355
59356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59357   int jresult ;
59358   int result;
59359
59360   {
59361     try {
59362       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59363     } catch (std::out_of_range& e) {
59364       {
59365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59366       };
59367     } catch (std::exception& e) {
59368       {
59369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59370       };
59371     } catch (Dali::DaliException e) {
59372       {
59373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59374       };
59375     } catch (...) {
59376       {
59377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59378       };
59379     }
59380   }
59381
59382   jresult = (int)result;
59383   return jresult;
59384 }
59385
59386
59387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59388   int jresult ;
59389   int result;
59390
59391   {
59392     try {
59393       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59394     } catch (std::out_of_range& e) {
59395       {
59396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59397       };
59398     } catch (std::exception& e) {
59399       {
59400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59401       };
59402     } catch (Dali::DaliException e) {
59403       {
59404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59405       };
59406     } catch (...) {
59407       {
59408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59409       };
59410     }
59411   }
59412
59413   jresult = (int)result;
59414   return jresult;
59415 }
59416
59417
59418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59419   int jresult ;
59420   int result;
59421
59422   {
59423     try {
59424       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59425     } catch (std::out_of_range& e) {
59426       {
59427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59428       };
59429     } catch (std::exception& e) {
59430       {
59431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59432       };
59433     } catch (Dali::DaliException e) {
59434       {
59435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59436       };
59437     } catch (...) {
59438       {
59439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59440       };
59441     }
59442   }
59443
59444   jresult = (int)result;
59445   return jresult;
59446 }
59447
59448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59449   int jresult ;
59450   int result;
59451
59452   {
59453     try {
59454       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59455     } catch (std::out_of_range& e) {
59456       {
59457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59458       };
59459     } catch (std::exception& e) {
59460       {
59461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59462       };
59463     } catch (Dali::DaliException e) {
59464       {
59465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59466       };
59467     } catch (...) {
59468       {
59469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59470       };
59471     }
59472   }
59473
59474   jresult = (int)result;
59475   return jresult;
59476 }
59477
59478
59479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59480   int jresult ;
59481   int result;
59482   {
59483     try
59484     {
59485       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59486     } catch (std::out_of_range& e) {
59487       {
59488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59489       };
59490     } catch (std::exception& e) {
59491       {
59492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59493       };
59494     } catch (Dali::DaliException e) {
59495       {
59496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59497       };
59498     } catch (...) {
59499       {
59500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59501       };
59502     }
59503   }
59504
59505   jresult = (int)result;
59506   return jresult;
59507 }
59508
59509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59510   int jresult ;
59511   int result;
59512   {
59513     try
59514     {
59515       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59516     } catch (std::out_of_range& e) {
59517       {
59518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59519       };
59520     } catch (std::exception& e) {
59521       {
59522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59523       };
59524     } catch (Dali::DaliException e) {
59525       {
59526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59527       };
59528     } catch (...) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59531       };
59532     }
59533   }
59534
59535   jresult = (int)result;
59536   return jresult;
59537 }
59538
59539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59540   int jresult ;
59541   int result;
59542   {
59543     try
59544     {
59545       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59546     } catch (std::out_of_range& e) {
59547       {
59548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59549       };
59550     } catch (std::exception& e) {
59551       {
59552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59553       };
59554     } catch (Dali::DaliException e) {
59555       {
59556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59557       };
59558     } catch (...) {
59559       {
59560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59561       };
59562     }
59563   }
59564
59565   jresult = (int)result;
59566   return jresult;
59567 }
59568
59569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59570   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59571 }
59572
59573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59574   int jresult ;
59575   int result;
59576   {
59577     try
59578     {
59579       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59580     } catch (std::out_of_range& e) {
59581       {
59582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (std::exception& e) {
59585       {
59586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59587       };
59588     } catch (Dali::DaliException e) {
59589       {
59590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59591       };
59592     } catch (...) {
59593       {
59594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59595       };
59596     }
59597   }
59598
59599   jresult = (int)result;
59600   return jresult;
59601 }
59602
59603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59604   int jresult ;
59605   int result;
59606   {
59607     try
59608     {
59609       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59610     } catch (std::out_of_range& e) {
59611       {
59612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59613       };
59614     } catch (std::exception& e) {
59615       {
59616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59617       };
59618     } catch (Dali::DaliException e) {
59619       {
59620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59621       };
59622     } catch (...) {
59623       {
59624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59625       };
59626     }
59627   }
59628
59629   jresult = (int)result;
59630   return jresult;
59631 }
59632
59633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59634   int jresult ;
59635   int result;
59636
59637   {
59638     try {
59639       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59640     } catch (std::out_of_range& e) {
59641       {
59642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (std::exception& e) {
59645       {
59646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (Dali::DaliException e) {
59649       {
59650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59651       };
59652     } catch (...) {
59653       {
59654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59655       };
59656     }
59657   }
59658
59659   jresult = (int)result;
59660   return jresult;
59661 }
59662
59663
59664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59665   int jresult ;
59666   int result;
59667
59668   {
59669     try {
59670       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59671     } catch (std::out_of_range& e) {
59672       {
59673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59674       };
59675     } catch (std::exception& e) {
59676       {
59677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59678       };
59679     } catch (Dali::DaliException e) {
59680       {
59681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59682       };
59683     } catch (...) {
59684       {
59685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59686       };
59687     }
59688   }
59689
59690   jresult = (int)result;
59691   return jresult;
59692 }
59693
59694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59695   int jresult ;
59696   int result;
59697   {
59698     try
59699     {
59700       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59701     } catch (std::out_of_range& e) {
59702       {
59703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59704       };
59705     } catch (std::exception& e) {
59706       {
59707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59708       };
59709     } catch (...) {
59710       {
59711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59712       };
59713     }
59714   }
59715   jresult = (int)result;
59716   return jresult;
59717 }
59718
59719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59720   int jresult ;
59721   int result;
59722   {
59723     try
59724     {
59725       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59737       };
59738     }
59739   }
59740   jresult = (int)result;
59741   return jresult;
59742 }
59743
59744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59745   int jresult ;
59746   int result;
59747   {
59748     try
59749     {
59750       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59751     } catch (std::out_of_range& e) {
59752       {
59753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59754       };
59755     } catch (std::exception& e) {
59756       {
59757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (...) {
59760       {
59761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59762       };
59763     }
59764   }
59765   jresult = (int)result;
59766   return jresult;
59767 }
59768
59769
59770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59771   int jresult ;
59772   int result;
59773   {
59774     try
59775     {
59776       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
59777     } catch (std::out_of_range& e) {
59778       {
59779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (std::exception& e) {
59782       {
59783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59784       };
59785     } catch (...) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59788       };
59789     }
59790   }
59791   jresult = (int)result;
59792   return jresult;
59793 }
59794
59795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
59796   int jresult ;
59797   int result;
59798   {
59799     try
59800     {
59801       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
59802     } catch (std::out_of_range& e) {
59803       {
59804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59805       };
59806     } catch (std::exception& e) {
59807       {
59808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59809       };
59810     } catch (...) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59813       };
59814     }
59815   }
59816   jresult = (int)result;
59817   return jresult;
59818 }
59819
59820
59821
59822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
59823   int jresult ;
59824   int result;
59825
59826   {
59827     try {
59828       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
59829     } catch (std::out_of_range& e) {
59830       {
59831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59832       };
59833     } catch (std::exception& e) {
59834       {
59835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59836       };
59837     } catch (Dali::DaliException e) {
59838       {
59839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59840       };
59841     } catch (...) {
59842       {
59843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59844       };
59845     }
59846   }
59847
59848   jresult = (int)result;
59849   return jresult;
59850 }
59851
59852
59853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
59854   int jresult ;
59855   int result;
59856
59857   {
59858     try {
59859       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
59860     } catch (std::out_of_range& e) {
59861       {
59862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59863       };
59864     } catch (std::exception& e) {
59865       {
59866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59867       };
59868     } catch (Dali::DaliException e) {
59869       {
59870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59871       };
59872     } catch (...) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59875       };
59876     }
59877   }
59878
59879   jresult = (int)result;
59880   return jresult;
59881 }
59882
59883
59884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
59885   int jresult ;
59886   int result;
59887
59888   {
59889     try {
59890       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
59891     } catch (std::out_of_range& e) {
59892       {
59893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59894       };
59895     } catch (std::exception& e) {
59896       {
59897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59898       };
59899     } catch (Dali::DaliException e) {
59900       {
59901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59902       };
59903     } catch (...) {
59904       {
59905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59906       };
59907     }
59908   }
59909
59910   jresult = (int)result;
59911   return jresult;
59912 }
59913
59914
59915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
59916   int jresult ;
59917   int result;
59918
59919   {
59920     try {
59921       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
59922     } catch (std::out_of_range& e) {
59923       {
59924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59925       };
59926     } catch (std::exception& e) {
59927       {
59928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (Dali::DaliException e) {
59931       {
59932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59933       };
59934     } catch (...) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59937       };
59938     }
59939   }
59940
59941   jresult = (int)result;
59942   return jresult;
59943 }
59944
59945
59946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
59947   int jresult ;
59948   int result;
59949
59950   {
59951     try {
59952       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
59953     } catch (std::out_of_range& e) {
59954       {
59955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59956       };
59957     } catch (std::exception& e) {
59958       {
59959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59960       };
59961     } catch (Dali::DaliException e) {
59962       {
59963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59964       };
59965     } catch (...) {
59966       {
59967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59968       };
59969     }
59970   }
59971
59972   jresult = (int)result;
59973   return jresult;
59974 }
59975
59976
59977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
59978   int jresult ;
59979   int result;
59980
59981   {
59982     try {
59983       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
59984     } catch (std::out_of_range& e) {
59985       {
59986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59987       };
59988     } catch (std::exception& e) {
59989       {
59990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (Dali::DaliException e) {
59993       {
59994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59995       };
59996     } catch (...) {
59997       {
59998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59999       };
60000     }
60001   }
60002
60003   jresult = (int)result;
60004   return jresult;
60005 }
60006
60007
60008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60009   int jresult ;
60010   int result;
60011
60012   {
60013     try {
60014       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60015     } catch (std::out_of_range& e) {
60016       {
60017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60018       };
60019     } catch (std::exception& e) {
60020       {
60021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60022       };
60023     } catch (Dali::DaliException e) {
60024       {
60025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60026       };
60027     } catch (...) {
60028       {
60029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60030       };
60031     }
60032   }
60033
60034   jresult = (int)result;
60035   return jresult;
60036 }
60037
60038 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60039   int jresult ;
60040   int result;
60041
60042   {
60043     try {
60044       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60045     } catch (std::out_of_range& e) {
60046       {
60047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60048       };
60049     } catch (std::exception& e) {
60050       {
60051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60052       };
60053     } catch (...) {
60054       {
60055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60056       };
60057     }
60058   }
60059   jresult = (int)result;
60060   return jresult;
60061 }
60062
60063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60064   int jresult ;
60065   int result;
60066
60067   {
60068     try {
60069       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60070     } catch (std::out_of_range& e) {
60071       {
60072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60073       };
60074     } catch (std::exception& e) {
60075       {
60076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60077       };
60078     } catch (Dali::DaliException e) {
60079       {
60080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60081       };
60082     } catch (...) {
60083       {
60084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60085       };
60086     }
60087   }
60088
60089   jresult = (int)result;
60090   return jresult;
60091 }
60092
60093
60094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60095   int jresult ;
60096   int result;
60097
60098   {
60099     try {
60100       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60101     } catch (std::out_of_range& e) {
60102       {
60103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60104       };
60105     } catch (std::exception& e) {
60106       {
60107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60108       };
60109     } catch (Dali::DaliException e) {
60110       {
60111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60112       };
60113     } catch (...) {
60114       {
60115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60116       };
60117     }
60118   }
60119
60120   jresult = (int)result;
60121   return jresult;
60122 }
60123
60124
60125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60126   int jresult ;
60127   int result;
60128
60129   {
60130     try {
60131       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60132     } catch (std::out_of_range& e) {
60133       {
60134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60135       };
60136     } catch (std::exception& e) {
60137       {
60138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60139       };
60140     } catch (Dali::DaliException e) {
60141       {
60142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60143       };
60144     } catch (...) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60147       };
60148     }
60149   }
60150
60151   jresult = (int)result;
60152   return jresult;
60153 }
60154
60155
60156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60157   int jresult ;
60158   int result;
60159
60160   {
60161     try {
60162       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60163     } catch (std::out_of_range& e) {
60164       {
60165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60166       };
60167     } catch (std::exception& e) {
60168       {
60169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60170       };
60171     } catch (Dali::DaliException e) {
60172       {
60173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60174       };
60175     } catch (...) {
60176       {
60177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60178       };
60179     }
60180   }
60181
60182   jresult = (int)result;
60183   return jresult;
60184 }
60185
60186
60187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60188   int jresult ;
60189   int result;
60190
60191   {
60192     try {
60193       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60194     } catch (std::out_of_range& e) {
60195       {
60196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60197       };
60198     } catch (std::exception& e) {
60199       {
60200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60201       };
60202     } catch (Dali::DaliException e) {
60203       {
60204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60205       };
60206     } catch (...) {
60207       {
60208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60209       };
60210     }
60211   }
60212
60213   jresult = (int)result;
60214   return jresult;
60215 }
60216
60217
60218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60219   int jresult ;
60220   int result;
60221
60222   {
60223     try {
60224       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60225     } catch (std::out_of_range& e) {
60226       {
60227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60228       };
60229     } catch (std::exception& e) {
60230       {
60231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60232       };
60233     } catch (Dali::DaliException e) {
60234       {
60235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60236       };
60237     } catch (...) {
60238       {
60239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60240       };
60241     }
60242   }
60243
60244   jresult = (int)result;
60245   return jresult;
60246 }
60247
60248
60249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60250   int jresult ;
60251   int result;
60252
60253   {
60254     try {
60255       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60256     } catch (std::out_of_range& e) {
60257       {
60258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60259       };
60260     } catch (std::exception& e) {
60261       {
60262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60263       };
60264     } catch (Dali::DaliException e) {
60265       {
60266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60267       };
60268     } catch (...) {
60269       {
60270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60271       };
60272     }
60273   }
60274
60275   jresult = (int)result;
60276   return jresult;
60277 }
60278
60279
60280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60281   int jresult ;
60282   int result;
60283
60284   {
60285     try {
60286       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60287     } catch (std::out_of_range& e) {
60288       {
60289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60290       };
60291     } catch (std::exception& e) {
60292       {
60293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60294       };
60295     } catch (Dali::DaliException e) {
60296       {
60297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60298       };
60299     } catch (...) {
60300       {
60301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60302       };
60303     }
60304   }
60305
60306   jresult = (int)result;
60307   return jresult;
60308 }
60309
60310
60311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60312   int jresult ;
60313   int result;
60314
60315   {
60316     try {
60317       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60318     } catch (std::out_of_range& e) {
60319       {
60320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (std::exception& e) {
60323       {
60324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (Dali::DaliException e) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60329       };
60330     } catch (...) {
60331       {
60332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60333       };
60334     }
60335   }
60336
60337   jresult = (int)result;
60338   return jresult;
60339 }
60340
60341
60342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60343   int jresult ;
60344   int result;
60345
60346   {
60347     try {
60348       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60349     } catch (std::out_of_range& e) {
60350       {
60351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60352       };
60353     } catch (std::exception& e) {
60354       {
60355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60356       };
60357     } catch (Dali::DaliException e) {
60358       {
60359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60360       };
60361     } catch (...) {
60362       {
60363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60364       };
60365     }
60366   }
60367
60368   jresult = (int)result;
60369   return jresult;
60370 }
60371
60372
60373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60374   int jresult ;
60375   int result;
60376
60377   {
60378     try {
60379       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60380     } catch (std::out_of_range& e) {
60381       {
60382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (std::exception& e) {
60385       {
60386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60387       };
60388     } catch (Dali::DaliException e) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60391       };
60392     } catch (...) {
60393       {
60394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60395       };
60396     }
60397   }
60398
60399   jresult = (int)result;
60400   return jresult;
60401 }
60402
60403
60404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60405   int jresult ;
60406   int result;
60407
60408   {
60409     try {
60410       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60411     } catch (std::out_of_range& e) {
60412       {
60413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (std::exception& e) {
60416       {
60417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60418       };
60419     } catch (Dali::DaliException e) {
60420       {
60421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60422       };
60423     } catch (...) {
60424       {
60425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60426       };
60427     }
60428   }
60429
60430   jresult = (int)result;
60431   return jresult;
60432 }
60433
60434
60435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60436   int jresult ;
60437   int result;
60438
60439   {
60440     try {
60441       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60442     } catch (std::out_of_range& e) {
60443       {
60444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60445       };
60446     } catch (std::exception& e) {
60447       {
60448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60449       };
60450     } catch (Dali::DaliException e) {
60451       {
60452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60453       };
60454     } catch (...) {
60455       {
60456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60457       };
60458     }
60459   }
60460
60461   jresult = (int)result;
60462   return jresult;
60463 }
60464
60465
60466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60467   int jresult ;
60468   int result;
60469
60470   {
60471     try {
60472       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60473     } catch (std::out_of_range& e) {
60474       {
60475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60476       };
60477     } catch (std::exception& e) {
60478       {
60479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60480       };
60481     } catch (Dali::DaliException e) {
60482       {
60483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60484       };
60485     } catch (...) {
60486       {
60487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60488       };
60489     }
60490   }
60491
60492   jresult = (int)result;
60493   return jresult;
60494 }
60495
60496
60497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60498   int jresult ;
60499   int result;
60500
60501   {
60502     try {
60503       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60504     } catch (std::out_of_range& e) {
60505       {
60506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60507       };
60508     } catch (std::exception& e) {
60509       {
60510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60511       };
60512     } catch (Dali::DaliException e) {
60513       {
60514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60515       };
60516     } catch (...) {
60517       {
60518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60519       };
60520     }
60521   }
60522
60523   jresult = (int)result;
60524   return jresult;
60525 }
60526
60527
60528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60529   int jresult ;
60530   int result;
60531
60532   {
60533     try {
60534       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60535     } catch (std::out_of_range& e) {
60536       {
60537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (std::exception& e) {
60540       {
60541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60542       };
60543     } catch (Dali::DaliException e) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60546       };
60547     } catch (...) {
60548       {
60549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60550       };
60551     }
60552   }
60553
60554   jresult = (int)result;
60555   return jresult;
60556 }
60557
60558
60559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60560   int jresult ;
60561   int result;
60562
60563   {
60564     try {
60565       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60566     } catch (std::out_of_range& e) {
60567       {
60568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60569       };
60570     } catch (std::exception& e) {
60571       {
60572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60573       };
60574     } catch (Dali::DaliException e) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60577       };
60578     } catch (...) {
60579       {
60580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60581       };
60582     }
60583   }
60584
60585   jresult = (int)result;
60586   return jresult;
60587 }
60588
60589
60590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60591   int jresult ;
60592   int result;
60593
60594   {
60595     try {
60596       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60597     } catch (std::out_of_range& e) {
60598       {
60599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60600       };
60601     } catch (std::exception& e) {
60602       {
60603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60604       };
60605     } catch (Dali::DaliException e) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60608       };
60609     } catch (...) {
60610       {
60611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60612       };
60613     }
60614   }
60615
60616   jresult = (int)result;
60617   return jresult;
60618 }
60619
60620
60621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60622   int jresult ;
60623   int result;
60624
60625   {
60626     try {
60627       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60628     } catch (std::out_of_range& e) {
60629       {
60630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60631       };
60632     } catch (std::exception& e) {
60633       {
60634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60635       };
60636     } catch (Dali::DaliException e) {
60637       {
60638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60639       };
60640     } catch (...) {
60641       {
60642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60643       };
60644     }
60645   }
60646
60647   jresult = (int)result;
60648   return jresult;
60649 }
60650
60651
60652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60653   int jresult ;
60654   int result;
60655
60656   {
60657     try {
60658       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60659     } catch (std::out_of_range& e) {
60660       {
60661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (std::exception& e) {
60664       {
60665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60666       };
60667     } catch (Dali::DaliException e) {
60668       {
60669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60670       };
60671     } catch (...) {
60672       {
60673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60674       };
60675     }
60676   }
60677
60678   jresult = (int)result;
60679   return jresult;
60680 }
60681
60682
60683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60684   int jresult ;
60685   int result;
60686
60687   {
60688     try {
60689       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60690     } catch (std::out_of_range& e) {
60691       {
60692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60693       };
60694     } catch (std::exception& e) {
60695       {
60696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60697       };
60698     } catch (Dali::DaliException e) {
60699       {
60700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60701       };
60702     } catch (...) {
60703       {
60704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60705       };
60706     }
60707   }
60708
60709   jresult = (int)result;
60710   return jresult;
60711 }
60712
60713
60714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60715   int jresult ;
60716   int result;
60717
60718   {
60719     try {
60720       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60721     } catch (std::out_of_range& e) {
60722       {
60723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60724       };
60725     } catch (std::exception& e) {
60726       {
60727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60728       };
60729     } catch (Dali::DaliException e) {
60730       {
60731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60732       };
60733     } catch (...) {
60734       {
60735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60736       };
60737     }
60738   }
60739
60740   jresult = (int)result;
60741   return jresult;
60742 }
60743
60744
60745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60746   int jresult ;
60747   int result;
60748
60749   {
60750     try {
60751       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60752     } catch (std::out_of_range& e) {
60753       {
60754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60755       };
60756     } catch (std::exception& e) {
60757       {
60758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60759       };
60760     } catch (Dali::DaliException e) {
60761       {
60762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60763       };
60764     } catch (...) {
60765       {
60766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60767       };
60768     }
60769   }
60770
60771   jresult = (int)result;
60772   return jresult;
60773 }
60774
60775
60776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
60777   int jresult ;
60778   int result;
60779
60780   {
60781     try {
60782       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
60783     } catch (std::out_of_range& e) {
60784       {
60785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60786       };
60787     } catch (std::exception& e) {
60788       {
60789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60790       };
60791     } catch (Dali::DaliException e) {
60792       {
60793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60794       };
60795     } catch (...) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60798       };
60799     }
60800   }
60801
60802   jresult = (int)result;
60803   return jresult;
60804 }
60805
60806
60807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
60808   int jresult ;
60809   int result;
60810
60811   {
60812     try {
60813       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
60814     } catch (std::out_of_range& e) {
60815       {
60816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60817       };
60818     } catch (std::exception& e) {
60819       {
60820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60821       };
60822     } catch (Dali::DaliException e) {
60823       {
60824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60825       };
60826     } catch (...) {
60827       {
60828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60829       };
60830     }
60831   }
60832
60833   jresult = (int)result;
60834   return jresult;
60835 }
60836
60837
60838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
60839   int jresult ;
60840   int result;
60841
60842   {
60843     try {
60844       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
60845     } catch (std::out_of_range& e) {
60846       {
60847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60848       };
60849     } catch (std::exception& e) {
60850       {
60851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60852       };
60853     } catch (Dali::DaliException e) {
60854       {
60855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60856       };
60857     } catch (...) {
60858       {
60859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60860       };
60861     }
60862   }
60863
60864   jresult = (int)result;
60865   return jresult;
60866 }
60867
60868
60869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
60870   int jresult ;
60871   int result;
60872
60873   {
60874     try {
60875       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
60876     } catch (std::out_of_range& e) {
60877       {
60878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60879       };
60880     } catch (std::exception& e) {
60881       {
60882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60883       };
60884     } catch (Dali::DaliException e) {
60885       {
60886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60887       };
60888     } catch (...) {
60889       {
60890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60891       };
60892     }
60893   }
60894
60895   jresult = (int)result;
60896   return jresult;
60897 }
60898
60899
60900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
60901   int jresult ;
60902   int result;
60903
60904   {
60905     try {
60906       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
60907     } catch (std::out_of_range& e) {
60908       {
60909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60910       };
60911     } catch (std::exception& e) {
60912       {
60913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60914       };
60915     } catch (Dali::DaliException e) {
60916       {
60917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60918       };
60919     } catch (...) {
60920       {
60921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60922       };
60923     }
60924   }
60925
60926   jresult = (int)result;
60927   return jresult;
60928 }
60929
60930
60931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
60932   void * jresult ;
60933   Dali::Toolkit::Builder *result = 0 ;
60934
60935   {
60936     try {
60937       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
60938     } catch (std::out_of_range& e) {
60939       {
60940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60941       };
60942     } catch (std::exception& e) {
60943       {
60944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60945       };
60946     } catch (Dali::DaliException e) {
60947       {
60948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60949       };
60950     } catch (...) {
60951       {
60952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60953       };
60954     }
60955   }
60956
60957   jresult = (void *)result;
60958   return jresult;
60959 }
60960
60961
60962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
60963   void * jresult ;
60964   Dali::Toolkit::Builder result;
60965
60966   {
60967     try {
60968       result = Dali::Toolkit::Builder::New();
60969     } catch (std::out_of_range& e) {
60970       {
60971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60972       };
60973     } catch (std::exception& e) {
60974       {
60975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60976       };
60977     } catch (Dali::DaliException e) {
60978       {
60979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60980       };
60981     } catch (...) {
60982       {
60983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60984       };
60985     }
60986   }
60987
60988   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
60989   return jresult;
60990 }
60991
60992
60993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
60994   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60995
60996   arg1 = (Dali::Toolkit::Builder *)jarg1;
60997   {
60998     try {
60999       delete arg1;
61000     } catch (std::out_of_range& e) {
61001       {
61002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61003       };
61004     } catch (std::exception& e) {
61005       {
61006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61007       };
61008     } catch (Dali::DaliException e) {
61009       {
61010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61011       };
61012     } catch (...) {
61013       {
61014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61015       };
61016     }
61017   }
61018
61019 }
61020
61021
61022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61023   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61024   std::string *arg2 = 0 ;
61025   Dali::Toolkit::Builder::UIFormat arg3 ;
61026
61027   arg1 = (Dali::Toolkit::Builder *)jarg1;
61028   if (!jarg2) {
61029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61030     return ;
61031   }
61032   std::string arg2_str(jarg2);
61033   arg2 = &arg2_str;
61034   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61035   {
61036     try {
61037       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61038     } catch (std::out_of_range& e) {
61039       {
61040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61041       };
61042     } catch (std::exception& e) {
61043       {
61044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61045       };
61046     } catch (Dali::DaliException e) {
61047       {
61048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61049       };
61050     } catch (...) {
61051       {
61052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61053       };
61054     }
61055   }
61056
61057
61058   //argout typemap for const std::string&
61059
61060 }
61061
61062
61063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61064   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61065   std::string *arg2 = 0 ;
61066
61067   arg1 = (Dali::Toolkit::Builder *)jarg1;
61068   if (!jarg2) {
61069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61070     return ;
61071   }
61072   std::string arg2_str(jarg2);
61073   arg2 = &arg2_str;
61074   {
61075     try {
61076       (arg1)->LoadFromString((std::string const &)*arg2);
61077     } catch (std::out_of_range& e) {
61078       {
61079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61080       };
61081     } catch (std::exception& e) {
61082       {
61083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61084       };
61085     } catch (Dali::DaliException e) {
61086       {
61087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61088       };
61089     } catch (...) {
61090       {
61091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61092       };
61093     }
61094   }
61095
61096
61097   //argout typemap for const std::string&
61098
61099 }
61100
61101
61102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61103   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61104   Dali::Property::Map *arg2 = 0 ;
61105
61106   arg1 = (Dali::Toolkit::Builder *)jarg1;
61107   arg2 = (Dali::Property::Map *)jarg2;
61108   if (!arg2) {
61109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61110     return ;
61111   }
61112   {
61113     try {
61114       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61115     } catch (std::out_of_range& e) {
61116       {
61117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61118       };
61119     } catch (std::exception& e) {
61120       {
61121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61122       };
61123     } catch (Dali::DaliException e) {
61124       {
61125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61126       };
61127     } catch (...) {
61128       {
61129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61130       };
61131     }
61132   }
61133
61134 }
61135
61136
61137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61138   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61139   std::string *arg2 = 0 ;
61140   Dali::Property::Value *arg3 = 0 ;
61141
61142   arg1 = (Dali::Toolkit::Builder *)jarg1;
61143   if (!jarg2) {
61144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61145     return ;
61146   }
61147   std::string arg2_str(jarg2);
61148   arg2 = &arg2_str;
61149   arg3 = (Dali::Property::Value *)jarg3;
61150   if (!arg3) {
61151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61152     return ;
61153   }
61154   {
61155     try {
61156       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61157     } catch (std::out_of_range& e) {
61158       {
61159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61160       };
61161     } catch (std::exception& e) {
61162       {
61163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61164       };
61165     } catch (Dali::DaliException e) {
61166       {
61167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61168       };
61169     } catch (...) {
61170       {
61171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61172       };
61173     }
61174   }
61175
61176
61177   //argout typemap for const std::string&
61178
61179 }
61180
61181
61182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61183   void * jresult ;
61184   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61185   Dali::Property::Map *result = 0 ;
61186
61187   arg1 = (Dali::Toolkit::Builder *)jarg1;
61188   {
61189     try {
61190       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61191     } catch (std::out_of_range& e) {
61192       {
61193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61194       };
61195     } catch (std::exception& e) {
61196       {
61197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (Dali::DaliException e) {
61200       {
61201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61202       };
61203     } catch (...) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61206       };
61207     }
61208   }
61209
61210   jresult = (void *)result;
61211   return jresult;
61212 }
61213
61214
61215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61216   void * jresult ;
61217   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61218   std::string *arg2 = 0 ;
61219   Dali::Property::Value *result = 0 ;
61220
61221   arg1 = (Dali::Toolkit::Builder *)jarg1;
61222   if (!jarg2) {
61223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61224     return 0;
61225   }
61226   std::string arg2_str(jarg2);
61227   arg2 = &arg2_str;
61228   {
61229     try {
61230       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61231     } catch (std::out_of_range& e) {
61232       {
61233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61234       };
61235     } catch (std::exception& e) {
61236       {
61237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61238       };
61239     } catch (Dali::DaliException e) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61242       };
61243     } catch (...) {
61244       {
61245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61246       };
61247     }
61248   }
61249
61250   jresult = (void *)result;
61251
61252   //argout typemap for const std::string&
61253
61254   return jresult;
61255 }
61256
61257
61258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61259   void * jresult ;
61260   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61261   std::string *arg2 = 0 ;
61262   Dali::Animation result;
61263
61264   arg1 = (Dali::Toolkit::Builder *)jarg1;
61265   if (!jarg2) {
61266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61267     return 0;
61268   }
61269   std::string arg2_str(jarg2);
61270   arg2 = &arg2_str;
61271   {
61272     try {
61273       result = (arg1)->CreateAnimation((std::string const &)*arg2);
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::Animation((const Dali::Animation &)result);
61294
61295   //argout typemap for const std::string&
61296
61297   return jresult;
61298 }
61299
61300
61301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61302   void * jresult ;
61303   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61304   std::string *arg2 = 0 ;
61305   Dali::Property::Map *arg3 = 0 ;
61306   Dali::Animation result;
61307
61308   arg1 = (Dali::Toolkit::Builder *)jarg1;
61309   if (!jarg2) {
61310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61311     return 0;
61312   }
61313   std::string arg2_str(jarg2);
61314   arg2 = &arg2_str;
61315   arg3 = (Dali::Property::Map *)jarg3;
61316   if (!arg3) {
61317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61318     return 0;
61319   }
61320   {
61321     try {
61322       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61323     } catch (std::out_of_range& e) {
61324       {
61325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61326       };
61327     } catch (std::exception& e) {
61328       {
61329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61330       };
61331     } catch (Dali::DaliException e) {
61332       {
61333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61334       };
61335     } catch (...) {
61336       {
61337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61338       };
61339     }
61340   }
61341
61342   jresult = new Dali::Animation((const Dali::Animation &)result);
61343
61344   //argout typemap for const std::string&
61345
61346   return jresult;
61347 }
61348
61349
61350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61351   void * jresult ;
61352   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61353   std::string *arg2 = 0 ;
61354   Dali::Actor arg3 ;
61355   Dali::Actor *argp3 ;
61356   Dali::Animation result;
61357
61358   arg1 = (Dali::Toolkit::Builder *)jarg1;
61359   if (!jarg2) {
61360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61361     return 0;
61362   }
61363   std::string arg2_str(jarg2);
61364   arg2 = &arg2_str;
61365   argp3 = (Dali::Actor *)jarg3;
61366   if (!argp3) {
61367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61368     return 0;
61369   }
61370   arg3 = *argp3;
61371   {
61372     try {
61373       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61374     } catch (std::out_of_range& e) {
61375       {
61376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61377       };
61378     } catch (std::exception& e) {
61379       {
61380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61381       };
61382     } catch (Dali::DaliException e) {
61383       {
61384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61385       };
61386     } catch (...) {
61387       {
61388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61389       };
61390     }
61391   }
61392
61393   jresult = new Dali::Animation((const Dali::Animation &)result);
61394
61395   //argout typemap for const std::string&
61396
61397   return jresult;
61398 }
61399
61400
61401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61402   void * jresult ;
61403   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61404   std::string *arg2 = 0 ;
61405   Dali::Property::Map *arg3 = 0 ;
61406   Dali::Actor arg4 ;
61407   Dali::Actor *argp4 ;
61408   Dali::Animation result;
61409
61410   arg1 = (Dali::Toolkit::Builder *)jarg1;
61411   if (!jarg2) {
61412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61413     return 0;
61414   }
61415   std::string arg2_str(jarg2);
61416   arg2 = &arg2_str;
61417   arg3 = (Dali::Property::Map *)jarg3;
61418   if (!arg3) {
61419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61420     return 0;
61421   }
61422   argp4 = (Dali::Actor *)jarg4;
61423   if (!argp4) {
61424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61425     return 0;
61426   }
61427   arg4 = *argp4;
61428   {
61429     try {
61430       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61431     } catch (std::out_of_range& e) {
61432       {
61433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61434       };
61435     } catch (std::exception& e) {
61436       {
61437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61438       };
61439     } catch (Dali::DaliException e) {
61440       {
61441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61442       };
61443     } catch (...) {
61444       {
61445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61446       };
61447     }
61448   }
61449
61450   jresult = new Dali::Animation((const Dali::Animation &)result);
61451
61452   //argout typemap for const std::string&
61453
61454   return jresult;
61455 }
61456
61457
61458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61459   void * jresult ;
61460   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61461   std::string *arg2 = 0 ;
61462   Dali::BaseHandle result;
61463
61464   arg1 = (Dali::Toolkit::Builder *)jarg1;
61465   if (!jarg2) {
61466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61467     return 0;
61468   }
61469   std::string arg2_str(jarg2);
61470   arg2 = &arg2_str;
61471   {
61472     try {
61473       result = (arg1)->Create((std::string const &)*arg2);
61474     } catch (std::out_of_range& e) {
61475       {
61476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61477       };
61478     } catch (std::exception& e) {
61479       {
61480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61481       };
61482     } catch (Dali::DaliException e) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61485       };
61486     } catch (...) {
61487       {
61488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61489       };
61490     }
61491   }
61492
61493   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61494
61495   //argout typemap for const std::string&
61496
61497   return jresult;
61498 }
61499
61500
61501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61502   void * jresult ;
61503   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61504   std::string *arg2 = 0 ;
61505   Dali::Property::Map *arg3 = 0 ;
61506   Dali::BaseHandle result;
61507
61508   arg1 = (Dali::Toolkit::Builder *)jarg1;
61509   if (!jarg2) {
61510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61511     return 0;
61512   }
61513   std::string arg2_str(jarg2);
61514   arg2 = &arg2_str;
61515   arg3 = (Dali::Property::Map *)jarg3;
61516   if (!arg3) {
61517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61518     return 0;
61519   }
61520   {
61521     try {
61522       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61523     } catch (std::out_of_range& e) {
61524       {
61525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61526       };
61527     } catch (std::exception& e) {
61528       {
61529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61530       };
61531     } catch (Dali::DaliException e) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61534       };
61535     } catch (...) {
61536       {
61537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61538       };
61539     }
61540   }
61541
61542   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61543
61544   //argout typemap for const std::string&
61545
61546   return jresult;
61547 }
61548
61549
61550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61551   void * jresult ;
61552   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61553   std::string *arg2 = 0 ;
61554   Dali::BaseHandle result;
61555
61556   arg1 = (Dali::Toolkit::Builder *)jarg1;
61557   if (!jarg2) {
61558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61559     return 0;
61560   }
61561   std::string arg2_str(jarg2);
61562   arg2 = &arg2_str;
61563   {
61564     try {
61565       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61566     } catch (std::out_of_range& e) {
61567       {
61568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (std::exception& e) {
61571       {
61572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61573       };
61574     } catch (Dali::DaliException e) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61577       };
61578     } catch (...) {
61579       {
61580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61581       };
61582     }
61583   }
61584
61585   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61586
61587   //argout typemap for const std::string&
61588
61589   return jresult;
61590 }
61591
61592
61593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61594   unsigned int jresult ;
61595   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61596   std::string *arg2 = 0 ;
61597   Dali::Handle *arg3 = 0 ;
61598   bool result;
61599
61600   arg1 = (Dali::Toolkit::Builder *)jarg1;
61601   if (!jarg2) {
61602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61603     return 0;
61604   }
61605   std::string arg2_str(jarg2);
61606   arg2 = &arg2_str;
61607   arg3 = (Dali::Handle *)jarg3;
61608   if (!arg3) {
61609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61610     return 0;
61611   }
61612   {
61613     try {
61614       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61615     } catch (std::out_of_range& e) {
61616       {
61617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61618       };
61619     } catch (std::exception& e) {
61620       {
61621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61622       };
61623     } catch (Dali::DaliException e) {
61624       {
61625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61626       };
61627     } catch (...) {
61628       {
61629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61630       };
61631     }
61632   }
61633
61634   jresult = result;
61635
61636   //argout typemap for const std::string&
61637
61638   return jresult;
61639 }
61640
61641
61642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61643   unsigned int jresult ;
61644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61645   Dali::Handle *arg2 = 0 ;
61646   std::string *arg3 = 0 ;
61647   bool result;
61648
61649   arg1 = (Dali::Toolkit::Builder *)jarg1;
61650   arg2 = (Dali::Handle *)jarg2;
61651   if (!arg2) {
61652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61653     return 0;
61654   }
61655   if (!jarg3) {
61656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61657     return 0;
61658   }
61659   std::string arg3_str(jarg3);
61660   arg3 = &arg3_str;
61661   {
61662     try {
61663       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61664     } catch (std::out_of_range& e) {
61665       {
61666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (std::exception& e) {
61669       {
61670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61671       };
61672     } catch (Dali::DaliException e) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61675       };
61676     } catch (...) {
61677       {
61678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61679       };
61680     }
61681   }
61682
61683   jresult = result;
61684
61685   //argout typemap for const std::string&
61686
61687   return jresult;
61688 }
61689
61690
61691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61692   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61693   Dali::Actor arg2 ;
61694   Dali::Actor *argp2 ;
61695
61696   arg1 = (Dali::Toolkit::Builder *)jarg1;
61697   argp2 = (Dali::Actor *)jarg2;
61698   if (!argp2) {
61699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61700     return ;
61701   }
61702   arg2 = *argp2;
61703   {
61704     try {
61705       (arg1)->AddActors(arg2);
61706     } catch (std::out_of_range& e) {
61707       {
61708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61709       };
61710     } catch (std::exception& e) {
61711       {
61712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61713       };
61714     } catch (Dali::DaliException e) {
61715       {
61716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61717       };
61718     } catch (...) {
61719       {
61720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61721       };
61722     }
61723   }
61724
61725 }
61726
61727
61728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61729   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61730   std::string *arg2 = 0 ;
61731   Dali::Actor arg3 ;
61732   Dali::Actor *argp3 ;
61733
61734   arg1 = (Dali::Toolkit::Builder *)jarg1;
61735   if (!jarg2) {
61736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61737     return ;
61738   }
61739   std::string arg2_str(jarg2);
61740   arg2 = &arg2_str;
61741   argp3 = (Dali::Actor *)jarg3;
61742   if (!argp3) {
61743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61744     return ;
61745   }
61746   arg3 = *argp3;
61747   {
61748     try {
61749       (arg1)->AddActors((std::string const &)*arg2,arg3);
61750     } catch (std::out_of_range& e) {
61751       {
61752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61753       };
61754     } catch (std::exception& e) {
61755       {
61756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61757       };
61758     } catch (Dali::DaliException e) {
61759       {
61760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61765       };
61766     }
61767   }
61768
61769
61770   //argout typemap for const std::string&
61771
61772 }
61773
61774
61775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
61776   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61777   std::string *arg2 = 0 ;
61778
61779   arg1 = (Dali::Toolkit::Builder *)jarg1;
61780   if (!jarg2) {
61781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61782     return ;
61783   }
61784   std::string arg2_str(jarg2);
61785   arg2 = &arg2_str;
61786   {
61787     try {
61788       (arg1)->CreateRenderTask((std::string const &)*arg2);
61789     } catch (std::out_of_range& e) {
61790       {
61791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61792       };
61793     } catch (std::exception& e) {
61794       {
61795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61796       };
61797     } catch (Dali::DaliException e) {
61798       {
61799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61800       };
61801     } catch (...) {
61802       {
61803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61804       };
61805     }
61806   }
61807
61808
61809   //argout typemap for const std::string&
61810
61811 }
61812
61813
61814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
61815   void * jresult ;
61816   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61817   std::string *arg2 = 0 ;
61818   Dali::Path result;
61819
61820   arg1 = (Dali::Toolkit::Builder *)jarg1;
61821   if (!jarg2) {
61822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61823     return 0;
61824   }
61825   std::string arg2_str(jarg2);
61826   arg2 = &arg2_str;
61827   {
61828     try {
61829       result = (arg1)->GetPath((std::string const &)*arg2);
61830     } catch (std::out_of_range& e) {
61831       {
61832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61833       };
61834     } catch (std::exception& e) {
61835       {
61836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61837       };
61838     } catch (Dali::DaliException e) {
61839       {
61840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61841       };
61842     } catch (...) {
61843       {
61844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61845       };
61846     }
61847   }
61848
61849   jresult = new Dali::Path((const Dali::Path &)result);
61850
61851   //argout typemap for const std::string&
61852
61853   return jresult;
61854 }
61855
61856
61857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
61858   void * jresult ;
61859   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61860   std::string *arg2 = 0 ;
61861   Dali::PathConstrainer result;
61862
61863   arg1 = (Dali::Toolkit::Builder *)jarg1;
61864   if (!jarg2) {
61865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61866     return 0;
61867   }
61868   std::string arg2_str(jarg2);
61869   arg2 = &arg2_str;
61870   {
61871     try {
61872       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
61873     } catch (std::out_of_range& e) {
61874       {
61875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61876       };
61877     } catch (std::exception& e) {
61878       {
61879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61880       };
61881     } catch (Dali::DaliException e) {
61882       {
61883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61884       };
61885     } catch (...) {
61886       {
61887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61888       };
61889     }
61890   }
61891
61892   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
61893
61894   //argout typemap for const std::string&
61895
61896   return jresult;
61897 }
61898
61899
61900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
61901   void * jresult ;
61902   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61903   std::string *arg2 = 0 ;
61904   Dali::LinearConstrainer result;
61905
61906   arg1 = (Dali::Toolkit::Builder *)jarg1;
61907   if (!jarg2) {
61908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61909     return 0;
61910   }
61911   std::string arg2_str(jarg2);
61912   arg2 = &arg2_str;
61913   {
61914     try {
61915       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
61916     } catch (std::out_of_range& e) {
61917       {
61918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61919       };
61920     } catch (std::exception& e) {
61921       {
61922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61923       };
61924     } catch (Dali::DaliException e) {
61925       {
61926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61927       };
61928     } catch (...) {
61929       {
61930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61931       };
61932     }
61933   }
61934
61935   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
61936
61937   //argout typemap for const std::string&
61938
61939   return jresult;
61940 }
61941
61942
61943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
61944   void * jresult ;
61945   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61946   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
61947
61948   arg1 = (Dali::Toolkit::Builder *)jarg1;
61949   {
61950     try {
61951       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
61952     } catch (std::out_of_range& e) {
61953       {
61954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61955       };
61956     } catch (std::exception& e) {
61957       {
61958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61959       };
61960     } catch (Dali::DaliException e) {
61961       {
61962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61963       };
61964     } catch (...) {
61965       {
61966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61967       };
61968     }
61969   }
61970
61971   jresult = (void *)result;
61972   return jresult;
61973 }
61974
61975
61976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
61977   void * jresult ;
61978   Dali::Toolkit::TransitionData *result = 0 ;
61979
61980   {
61981     try {
61982       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61990       };
61991     } catch (Dali::DaliException e) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61994       };
61995     } catch (...) {
61996       {
61997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61998       };
61999     }
62000   }
62001
62002   jresult = (void *)result;
62003   return jresult;
62004 }
62005
62006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62007   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62008
62009   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62010   {
62011     try {
62012       delete arg1;
62013     } catch (std::out_of_range& e) {
62014       {
62015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62016       };
62017     } catch (std::exception& e) {
62018       {
62019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62020       };
62021     } catch (Dali::DaliException e) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62024       };
62025     } catch (...) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62028       };
62029     }
62030   }
62031
62032 }
62033
62034
62035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62036   void * jresult ;
62037   Dali::Property::Map *arg1 = 0 ;
62038   Dali::Toolkit::TransitionData result;
62039
62040   arg1 = (Dali::Property::Map *)jarg1;
62041   if (!arg1) {
62042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62043     return 0;
62044   }
62045   {
62046     try {
62047       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62055       };
62056     } catch (Dali::DaliException e) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62059       };
62060     } catch (...) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62063       };
62064     }
62065   }
62066
62067   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62068   return jresult;
62069 }
62070
62071
62072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62073   void * jresult ;
62074   Dali::Property::Array *arg1 = 0 ;
62075   Dali::Toolkit::TransitionData result;
62076
62077   arg1 = (Dali::Property::Array *)jarg1;
62078   if (!arg1) {
62079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62080     return 0;
62081   }
62082   {
62083     try {
62084       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62085     } catch (std::out_of_range& e) {
62086       {
62087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62088       };
62089     } catch (std::exception& e) {
62090       {
62091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62092       };
62093     } catch (Dali::DaliException e) {
62094       {
62095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62096       };
62097     } catch (...) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62100       };
62101     }
62102   }
62103
62104   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62105   return jresult;
62106 }
62107
62108
62109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62110   void * jresult ;
62111   Dali::BaseHandle arg1 ;
62112   Dali::BaseHandle *argp1 ;
62113   Dali::Toolkit::TransitionData result;
62114
62115   argp1 = (Dali::BaseHandle *)jarg1;
62116   if (!argp1) {
62117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62118     return 0;
62119   }
62120   arg1 = *argp1;
62121   {
62122     try {
62123       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62131       };
62132     } catch (Dali::DaliException e) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62135       };
62136     } catch (...) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62139       };
62140     }
62141   }
62142
62143   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62144   return jresult;
62145 }
62146
62147
62148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62149   void * jresult ;
62150   Dali::Toolkit::TransitionData *arg1 = 0 ;
62151   Dali::Toolkit::TransitionData *result = 0 ;
62152
62153   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62154   if (!arg1) {
62155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62156     return 0;
62157   }
62158   {
62159     try {
62160       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62161     } catch (std::out_of_range& e) {
62162       {
62163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62164       };
62165     } catch (std::exception& e) {
62166       {
62167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62168       };
62169     } catch (Dali::DaliException e) {
62170       {
62171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62172       };
62173     } catch (...) {
62174       {
62175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62176       };
62177     }
62178   }
62179
62180   jresult = (void *)result;
62181   return jresult;
62182 }
62183
62184
62185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62186   void * jresult ;
62187   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62188   Dali::Toolkit::TransitionData *arg2 = 0 ;
62189   Dali::Toolkit::TransitionData *result = 0 ;
62190
62191   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62192   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62193   if (!arg2) {
62194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62195     return 0;
62196   }
62197   {
62198     try {
62199       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62200     } catch (std::out_of_range& e) {
62201       {
62202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62203       };
62204     } catch (std::exception& e) {
62205       {
62206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62207       };
62208     } catch (Dali::DaliException e) {
62209       {
62210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62211       };
62212     } catch (...) {
62213       {
62214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62215       };
62216     }
62217   }
62218
62219   jresult = (void *)result;
62220   return jresult;
62221 }
62222
62223
62224 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62225   unsigned long jresult ;
62226   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62227   size_t result;
62228
62229   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62230   {
62231     try {
62232       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62233     } catch (std::out_of_range& e) {
62234       {
62235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62236       };
62237     } catch (std::exception& e) {
62238       {
62239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62240       };
62241     } catch (Dali::DaliException e) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62244       };
62245     } catch (...) {
62246       {
62247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62248       };
62249     }
62250   }
62251
62252   jresult = (unsigned long)result;
62253   return jresult;
62254 }
62255
62256
62257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62258   void * jresult ;
62259   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62260   size_t arg2 ;
62261   Dali::Property::Map result;
62262
62263   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62264   arg2 = (size_t)jarg2;
62265   {
62266     try {
62267       result = (arg1)->GetAnimatorAt(arg2);
62268     } catch (std::out_of_range& e) {
62269       {
62270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62271       };
62272     } catch (std::exception& e) {
62273       {
62274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62275       };
62276     } catch (Dali::DaliException e) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62279       };
62280     } catch (...) {
62281       {
62282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62283       };
62284     }
62285   }
62286
62287   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62288   return jresult;
62289 }
62290
62291
62292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62293   int jresult ;
62294   int result;
62295
62296   {
62297     try {
62298       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62299     } catch (std::out_of_range& e) {
62300       {
62301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62302       };
62303     } catch (std::exception& e) {
62304       {
62305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62306       };
62307     } catch (Dali::DaliException e) {
62308       {
62309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62310       };
62311     } catch (...) {
62312       {
62313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62314       };
62315     }
62316   }
62317
62318   jresult = (int)result;
62319   return jresult;
62320 }
62321
62322
62323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62324   int jresult ;
62325   int result;
62326
62327   {
62328     try {
62329       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62330     } catch (std::out_of_range& e) {
62331       {
62332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62333       };
62334     } catch (std::exception& e) {
62335       {
62336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62337       };
62338     } catch (Dali::DaliException e) {
62339       {
62340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62341       };
62342     } catch (...) {
62343       {
62344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62345       };
62346     }
62347   }
62348
62349   jresult = (int)result;
62350   return jresult;
62351 }
62352
62353
62354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62355   int jresult ;
62356   int result;
62357
62358   {
62359     try {
62360       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62361     } catch (std::out_of_range& e) {
62362       {
62363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62364       };
62365     } catch (std::exception& e) {
62366       {
62367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62368       };
62369     } catch (Dali::DaliException e) {
62370       {
62371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62372       };
62373     } catch (...) {
62374       {
62375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62376       };
62377     }
62378   }
62379
62380   jresult = (int)result;
62381   return jresult;
62382 }
62383
62384
62385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62386   int jresult ;
62387   int result;
62388
62389   {
62390     try {
62391       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62399       };
62400     } catch (Dali::DaliException e) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62403       };
62404     } catch (...) {
62405       {
62406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62407       };
62408     }
62409   }
62410
62411   jresult = (int)result;
62412   return jresult;
62413 }
62414
62415
62416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62417   int jresult ;
62418   int result;
62419
62420   {
62421     try {
62422       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62423     } catch (std::out_of_range& e) {
62424       {
62425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62426       };
62427     } catch (std::exception& e) {
62428       {
62429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (Dali::DaliException e) {
62432       {
62433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62434       };
62435     } catch (...) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62438       };
62439     }
62440   }
62441
62442   jresult = (int)result;
62443   return jresult;
62444 }
62445
62446
62447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62448   int jresult ;
62449   int result;
62450
62451   {
62452     try {
62453       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62454     } catch (std::out_of_range& e) {
62455       {
62456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62457       };
62458     } catch (std::exception& e) {
62459       {
62460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62461       };
62462     } catch (Dali::DaliException e) {
62463       {
62464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62465       };
62466     } catch (...) {
62467       {
62468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62469       };
62470     }
62471   }
62472
62473   jresult = (int)result;
62474   return jresult;
62475 }
62476
62477
62478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62479   int jresult ;
62480   int result;
62481
62482   {
62483     try {
62484       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62485     } catch (std::out_of_range& e) {
62486       {
62487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62488       };
62489     } catch (std::exception& e) {
62490       {
62491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62492       };
62493     } catch (Dali::DaliException e) {
62494       {
62495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62496       };
62497     } catch (...) {
62498       {
62499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62500       };
62501     }
62502   }
62503
62504   jresult = (int)result;
62505   return jresult;
62506 }
62507
62508
62509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62510   int jresult ;
62511   int result;
62512
62513   {
62514     try {
62515       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62516     } catch (std::out_of_range& e) {
62517       {
62518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62519       };
62520     } catch (std::exception& e) {
62521       {
62522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62523       };
62524     } catch (Dali::DaliException e) {
62525       {
62526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62527       };
62528     } catch (...) {
62529       {
62530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62531       };
62532     }
62533   }
62534
62535   jresult = (int)result;
62536   return jresult;
62537 }
62538
62539
62540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62541   int jresult ;
62542   int result;
62543
62544   {
62545     try {
62546       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62547     } catch (std::out_of_range& e) {
62548       {
62549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62550       };
62551     } catch (std::exception& e) {
62552       {
62553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62554       };
62555     } catch (Dali::DaliException e) {
62556       {
62557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62558       };
62559     } catch (...) {
62560       {
62561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62562       };
62563     }
62564   }
62565
62566   jresult = (int)result;
62567   return jresult;
62568 }
62569
62570
62571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62572   int jresult ;
62573   int result;
62574
62575   {
62576     try {
62577       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62578     } catch (std::out_of_range& e) {
62579       {
62580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62581       };
62582     } catch (std::exception& e) {
62583       {
62584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62585       };
62586     } catch (Dali::DaliException e) {
62587       {
62588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62589       };
62590     } catch (...) {
62591       {
62592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62593       };
62594     }
62595   }
62596
62597   jresult = (int)result;
62598   return jresult;
62599 }
62600
62601
62602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62603   int jresult ;
62604   int result;
62605
62606   {
62607     try {
62608       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62609     } catch (std::out_of_range& e) {
62610       {
62611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62612       };
62613     } catch (std::exception& e) {
62614       {
62615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62616       };
62617     } catch (Dali::DaliException e) {
62618       {
62619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62620       };
62621     } catch (...) {
62622       {
62623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62624       };
62625     }
62626   }
62627
62628   jresult = (int)result;
62629   return jresult;
62630 }
62631
62632
62633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62634   int jresult ;
62635   int result;
62636
62637   {
62638     try {
62639       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62640     } catch (std::out_of_range& e) {
62641       {
62642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62643       };
62644     } catch (std::exception& e) {
62645       {
62646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62647       };
62648     } catch (Dali::DaliException e) {
62649       {
62650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62651       };
62652     } catch (...) {
62653       {
62654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62655       };
62656     }
62657   }
62658
62659   jresult = (int)result;
62660   return jresult;
62661 }
62662
62663
62664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62665   int jresult ;
62666   int result;
62667
62668   {
62669     try {
62670       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62671     } catch (std::out_of_range& e) {
62672       {
62673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62674       };
62675     } catch (std::exception& e) {
62676       {
62677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62678       };
62679     } catch (Dali::DaliException e) {
62680       {
62681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62682       };
62683     } catch (...) {
62684       {
62685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62686       };
62687     }
62688   }
62689
62690   jresult = (int)result;
62691   return jresult;
62692 }
62693
62694
62695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62696   int jresult ;
62697   int result;
62698
62699   {
62700     try {
62701       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62702     } catch (std::out_of_range& e) {
62703       {
62704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62705       };
62706     } catch (std::exception& e) {
62707       {
62708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62709       };
62710     } catch (Dali::DaliException e) {
62711       {
62712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62713       };
62714     } catch (...) {
62715       {
62716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62717       };
62718     }
62719   }
62720
62721   jresult = (int)result;
62722   return jresult;
62723 }
62724
62725
62726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62727   void * jresult ;
62728   Dali::Toolkit::Control result;
62729
62730   {
62731     try {
62732       result = Dali::Toolkit::Internal::Control::New();
62733     } catch (std::out_of_range& e) {
62734       {
62735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62736       };
62737     } catch (std::exception& e) {
62738       {
62739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62740       };
62741     } catch (Dali::DaliException e) {
62742       {
62743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62744       };
62745     } catch (...) {
62746       {
62747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62748       };
62749     }
62750   }
62751
62752   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62753   return jresult;
62754 }
62755
62756
62757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62759   std::string *arg2 = 0 ;
62760
62761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62762   if (!jarg2) {
62763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62764     return ;
62765   }
62766   std::string arg2_str(jarg2);
62767   arg2 = &arg2_str;
62768   {
62769     try {
62770       (arg1)->SetStyleName((std::string const &)*arg2);
62771     } catch (std::out_of_range& e) {
62772       {
62773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62774       };
62775     } catch (std::exception& e) {
62776       {
62777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62778       };
62779     } catch (Dali::DaliException e) {
62780       {
62781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62782       };
62783     } catch (...) {
62784       {
62785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62786       };
62787     }
62788   }
62789
62790
62791   //argout typemap for const std::string&
62792
62793 }
62794
62795
62796 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
62797   char * jresult ;
62798   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62799   std::string *result = 0 ;
62800
62801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62802   {
62803     try {
62804       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
62805     } catch (std::out_of_range& e) {
62806       {
62807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62808       };
62809     } catch (std::exception& e) {
62810       {
62811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62812       };
62813     } catch (Dali::DaliException e) {
62814       {
62815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62816       };
62817     } catch (...) {
62818       {
62819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62820       };
62821     }
62822   }
62823
62824   jresult = SWIG_csharp_string_callback(result->c_str());
62825   return jresult;
62826 }
62827
62828
62829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
62830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62831   Dali::Vector4 *arg2 = 0 ;
62832
62833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62834   arg2 = (Dali::Vector4 *)jarg2;
62835   if (!arg2) {
62836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62837     return ;
62838   }
62839   {
62840     try {
62841       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62842     } catch (std::out_of_range& e) {
62843       {
62844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62845       };
62846     } catch (std::exception& e) {
62847       {
62848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62849       };
62850     } catch (Dali::DaliException e) {
62851       {
62852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62853       };
62854     } catch (...) {
62855       {
62856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62857       };
62858     }
62859   }
62860
62861 }
62862
62863
62864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
62865   void * jresult ;
62866   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
62867   Dali::Vector4 result;
62868
62869   arg1 = (Dali::Handle *)jarg1;
62870   {
62871     try {
62872       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
62873       if (resultMap)
62874       {
62875         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
62876         if(type && type->Get<int>() == Visual::COLOR )
62877         {
62878           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
62879           if (value)
62880           {
62881             result = value->Get<Vector4>();
62882           }
62883         }
62884       }
62885     } catch (std::out_of_range& e) {
62886       {
62887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62888       };
62889     } catch (std::exception& e) {
62890       {
62891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62892       };
62893     } catch (Dali::DaliException e) {
62894       {
62895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62896       };
62897     } catch (...) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62900       };
62901     }
62902   }
62903
62904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62905   return jresult;
62906 }
62907
62908
62909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
62910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62911   Dali::Property::Map *arg2 = 0 ;
62912
62913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62914   arg2 = (Dali::Property::Map *)jarg2;
62915   if (!arg2) {
62916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62917     return ;
62918   }
62919   {
62920     try {
62921       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
62922     } catch (std::out_of_range& e) {
62923       {
62924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62925       };
62926     } catch (std::exception& e) {
62927       {
62928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62929       };
62930     } catch (Dali::DaliException e) {
62931       {
62932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62933       };
62934     } catch (...) {
62935       {
62936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62937       };
62938     }
62939   }
62940
62941 }
62942
62943
62944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
62945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62946
62947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62948   {
62949     try {
62950       (arg1)->ClearBackground();
62951     } catch (std::out_of_range& e) {
62952       {
62953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62954       };
62955     } catch (std::exception& e) {
62956       {
62957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62958       };
62959     } catch (Dali::DaliException e) {
62960       {
62961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62966       };
62967     }
62968   }
62969
62970 }
62971
62972
62973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
62974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62975   Dali::Gesture::Type arg2 ;
62976
62977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62978   arg2 = (Dali::Gesture::Type)jarg2;
62979   {
62980     try {
62981       (arg1)->EnableGestureDetection(arg2);
62982     } catch (std::out_of_range& e) {
62983       {
62984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62985       };
62986     } catch (std::exception& e) {
62987       {
62988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62989       };
62990     } catch (Dali::DaliException e) {
62991       {
62992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62993       };
62994     } catch (...) {
62995       {
62996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62997       };
62998     }
62999   }
63000
63001 }
63002
63003
63004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63006   Dali::Gesture::Type arg2 ;
63007
63008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63009   arg2 = (Dali::Gesture::Type)jarg2;
63010   {
63011     try {
63012       (arg1)->DisableGestureDetection(arg2);
63013     } catch (std::out_of_range& e) {
63014       {
63015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63016       };
63017     } catch (std::exception& e) {
63018       {
63019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63020       };
63021     } catch (Dali::DaliException e) {
63022       {
63023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63024       };
63025     } catch (...) {
63026       {
63027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63028       };
63029     }
63030   }
63031
63032 }
63033
63034
63035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63036   void * jresult ;
63037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63038   Dali::PinchGestureDetector result;
63039
63040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63041   {
63042     try {
63043       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63044     } catch (std::out_of_range& e) {
63045       {
63046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63047       };
63048     } catch (std::exception& e) {
63049       {
63050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63051       };
63052     } catch (Dali::DaliException e) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63055       };
63056     } catch (...) {
63057       {
63058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63059       };
63060     }
63061   }
63062
63063   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63064   return jresult;
63065 }
63066
63067
63068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63069   void * jresult ;
63070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63071   Dali::PanGestureDetector result;
63072
63073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63074   {
63075     try {
63076       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63084       };
63085     } catch (Dali::DaliException e) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63092       };
63093     }
63094   }
63095
63096   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63097   return jresult;
63098 }
63099
63100
63101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63102   void * jresult ;
63103   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63104   Dali::TapGestureDetector result;
63105
63106   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63107   {
63108     try {
63109       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63130   return jresult;
63131 }
63132
63133
63134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63135   void * jresult ;
63136   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63137   Dali::LongPressGestureDetector result;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   {
63141     try {
63142       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63143     } catch (std::out_of_range& e) {
63144       {
63145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (std::exception& e) {
63148       {
63149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63150       };
63151     } catch (Dali::DaliException e) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63154       };
63155     } catch (...) {
63156       {
63157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63158       };
63159     }
63160   }
63161
63162   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63163   return jresult;
63164 }
63165
63166
63167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63169   bool arg2 ;
63170
63171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63172   arg2 = jarg2 ? true : false;
63173   {
63174     try {
63175       (arg1)->SetKeyboardNavigationSupport(arg2);
63176     } catch (std::out_of_range& e) {
63177       {
63178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63179       };
63180     } catch (std::exception& e) {
63181       {
63182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63183       };
63184     } catch (Dali::DaliException e) {
63185       {
63186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63187       };
63188     } catch (...) {
63189       {
63190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63191       };
63192     }
63193   }
63194
63195 }
63196
63197
63198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63199   unsigned int jresult ;
63200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63201   bool result;
63202
63203   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63204   {
63205     try {
63206       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63207     } catch (std::out_of_range& e) {
63208       {
63209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63210       };
63211     } catch (std::exception& e) {
63212       {
63213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63214       };
63215     } catch (Dali::DaliException e) {
63216       {
63217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63218       };
63219     } catch (...) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63222       };
63223     }
63224   }
63225
63226   jresult = result;
63227   return jresult;
63228 }
63229
63230
63231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63233
63234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63235   {
63236     try {
63237       (arg1)->SetKeyInputFocus();
63238     } catch (std::out_of_range& e) {
63239       {
63240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63241       };
63242     } catch (std::exception& e) {
63243       {
63244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63245       };
63246     } catch (Dali::DaliException e) {
63247       {
63248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63249       };
63250     } catch (...) {
63251       {
63252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63253       };
63254     }
63255   }
63256
63257 }
63258
63259
63260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63261   unsigned int jresult ;
63262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63263   bool result;
63264
63265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63266   {
63267     try {
63268       result = (bool)(arg1)->HasKeyInputFocus();
63269     } catch (std::out_of_range& e) {
63270       {
63271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63272       };
63273     } catch (std::exception& e) {
63274       {
63275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63276       };
63277     } catch (Dali::DaliException e) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63280       };
63281     } catch (...) {
63282       {
63283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63284       };
63285     }
63286   }
63287
63288   jresult = result;
63289   return jresult;
63290 }
63291
63292
63293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63295
63296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63297   {
63298     try {
63299       (arg1)->ClearKeyInputFocus();
63300     } catch (std::out_of_range& e) {
63301       {
63302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63303       };
63304     } catch (std::exception& e) {
63305       {
63306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63307       };
63308     } catch (Dali::DaliException e) {
63309       {
63310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63311       };
63312     } catch (...) {
63313       {
63314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63315       };
63316     }
63317   }
63318
63319 }
63320
63321
63322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63324   bool arg2 ;
63325
63326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63327   arg2 = jarg2 ? true : false;
63328   {
63329     try {
63330       (arg1)->SetAsKeyboardFocusGroup(arg2);
63331     } catch (std::out_of_range& e) {
63332       {
63333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63334       };
63335     } catch (std::exception& e) {
63336       {
63337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63338       };
63339     } catch (Dali::DaliException e) {
63340       {
63341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63342       };
63343     } catch (...) {
63344       {
63345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63346       };
63347     }
63348   }
63349
63350 }
63351
63352
63353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63354   unsigned int jresult ;
63355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63356   bool result;
63357
63358   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63359   {
63360     try {
63361       result = (bool)(arg1)->IsKeyboardFocusGroup();
63362     } catch (std::out_of_range& e) {
63363       {
63364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (std::exception& e) {
63367       {
63368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63369       };
63370     } catch (Dali::DaliException e) {
63371       {
63372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63373       };
63374     } catch (...) {
63375       {
63376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63377       };
63378     }
63379   }
63380
63381   jresult = result;
63382   return jresult;
63383 }
63384
63385
63386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63387   void * jresult ;
63388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63389   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63390
63391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63392   {
63393     try {
63394       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63395     } catch (std::out_of_range& e) {
63396       {
63397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63398       };
63399     } catch (std::exception& e) {
63400       {
63401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63402       };
63403     } catch (Dali::DaliException e) {
63404       {
63405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63406       };
63407     } catch (...) {
63408       {
63409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63410       };
63411     }
63412   }
63413
63414   jresult = (void *)result;
63415   return jresult;
63416 }
63417
63418
63419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63420   void * jresult ;
63421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63422   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63423
63424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63425   {
63426     try {
63427       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63428     } catch (std::out_of_range& e) {
63429       {
63430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63431       };
63432     } catch (std::exception& e) {
63433       {
63434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63435       };
63436     } catch (Dali::DaliException e) {
63437       {
63438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63439       };
63440     } catch (...) {
63441       {
63442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63443       };
63444     }
63445   }
63446
63447   jresult = (void *)result;
63448   return jresult;
63449 }
63450
63451
63452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63453   void * jresult ;
63454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63455   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63456
63457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63458   {
63459     try {
63460       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63461     } catch (std::out_of_range& e) {
63462       {
63463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63464       };
63465     } catch (std::exception& e) {
63466       {
63467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63468       };
63469     } catch (Dali::DaliException e) {
63470       {
63471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63472       };
63473     } catch (...) {
63474       {
63475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63476       };
63477     }
63478   }
63479
63480   jresult = (void *)result;
63481   return jresult;
63482 }
63483
63484
63485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63487   int arg2 ;
63488   SwigDirector_ViewImpl *darg = 0;
63489
63490   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63491   arg2 = (int)jarg2;
63492   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63493   if(!darg) {
63494     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63495     return;
63496   }
63497   {
63498     try {
63499       if(darg) {
63500         (darg)->OnStageConnection(arg2);
63501       }
63502     } catch (std::out_of_range& e) {
63503       {
63504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63505       };
63506     } catch (std::exception& e) {
63507       {
63508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63509       };
63510     } catch (Dali::DaliException e) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63513       };
63514     } catch (...) {
63515       {
63516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63517       };
63518     }
63519   }
63520
63521 }
63522
63523
63524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63526   int arg2 ;
63527   SwigDirector_ViewImpl *darg = 0;
63528
63529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63530   arg2 = (int)jarg2;
63531   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63532   if(!darg) {
63533     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63534     return;
63535   }
63536   {
63537     try {
63538       if(darg) {
63539         (darg)->OnStageConnectionSwigPublic(arg2);
63540       }
63541     } catch (std::out_of_range& e) {
63542       {
63543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63544       };
63545     } catch (std::exception& e) {
63546       {
63547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63548       };
63549     } catch (Dali::DaliException e) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63552       };
63553     } catch (...) {
63554       {
63555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63556       };
63557     }
63558   }
63559
63560 }
63561
63562
63563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63565   SwigDirector_ViewImpl *darg = 0;
63566
63567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63569   if(!darg) {
63570     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63571     return;
63572   }
63573   {
63574     try {
63575       if(darg) {
63576         (darg)->OnStageDisconnection();
63577       }
63578     } catch (std::out_of_range& e) {
63579       {
63580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63581       };
63582     } catch (std::exception& e) {
63583       {
63584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63585       };
63586     } catch (Dali::DaliException e) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63589       };
63590     } catch (...) {
63591       {
63592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63593       };
63594     }
63595   }
63596
63597 }
63598
63599
63600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63602   SwigDirector_ViewImpl *darg = 0;
63603
63604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63605   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63606   if(!darg) {
63607     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63608     return;
63609   }
63610   {
63611     try {
63612       if(darg) {
63613         (darg)->OnStageDisconnectionSwigPublic();
63614       }
63615     } catch (std::out_of_range& e) {
63616       {
63617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63618       };
63619     } catch (std::exception& e) {
63620       {
63621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63622       };
63623     } catch (Dali::DaliException e) {
63624       {
63625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63626       };
63627     } catch (...) {
63628       {
63629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63630       };
63631     }
63632   }
63633
63634 }
63635
63636
63637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63639   Dali::Actor *arg2 = 0 ;
63640   SwigDirector_ViewImpl *darg = 0;
63641
63642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63643   arg2 = (Dali::Actor *)jarg2;
63644   if (!arg2) {
63645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63646     return ;
63647   }
63648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63649   if(!darg) {
63650     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63651     return;
63652   }
63653   {
63654     try {
63655       if(darg) {
63656         (darg)->OnChildAdd(*arg2);
63657       }
63658     } catch (std::out_of_range& e) {
63659       {
63660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63661       };
63662     } catch (std::exception& e) {
63663       {
63664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63665       };
63666     } catch (Dali::DaliException e) {
63667       {
63668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63669       };
63670     } catch (...) {
63671       {
63672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63673       };
63674     }
63675   }
63676
63677 }
63678
63679
63680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63682   Dali::Actor *arg2 = 0 ;
63683   SwigDirector_ViewImpl *darg = 0;
63684
63685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63686   arg2 = (Dali::Actor *)jarg2;
63687   if (!arg2) {
63688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63689     return ;
63690   }
63691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63692   if(!darg) {
63693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63694     return;
63695   }
63696   {
63697     try {
63698       if(darg) {
63699           (darg)->OnChildAddSwigPublic(*arg2);
63700       }
63701     } catch (std::out_of_range& e) {
63702       {
63703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63704       };
63705     } catch (std::exception& e) {
63706       {
63707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63708       };
63709     } catch (Dali::DaliException e) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63712       };
63713     } catch (...) {
63714       {
63715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63716       };
63717     }
63718   }
63719
63720 }
63721
63722
63723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63725   Dali::Actor *arg2 = 0 ;
63726   SwigDirector_ViewImpl *darg = 0;
63727
63728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63729   arg2 = (Dali::Actor *)jarg2;
63730   if (!arg2) {
63731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63732     return ;
63733   }
63734   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63735   if(!darg) {
63736     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63737     return;
63738   }
63739   {
63740     try {
63741       if(darg) {
63742         (darg)->OnChildRemove(*arg2);
63743       }
63744     } catch (std::out_of_range& e) {
63745       {
63746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63747       };
63748     } catch (std::exception& e) {
63749       {
63750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63751       };
63752     } catch (Dali::DaliException e) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63755       };
63756     } catch (...) {
63757       {
63758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63759       };
63760     }
63761   }
63762
63763 }
63764
63765
63766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63767   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63768   Dali::Actor *arg2 = 0 ;
63769   SwigDirector_ViewImpl *darg = 0;
63770
63771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63772   arg2 = (Dali::Actor *)jarg2;
63773   if (!arg2) {
63774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63775     return ;
63776   }
63777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63778   if(!darg) {
63779     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63780     return;
63781   }
63782   {
63783     try {
63784       if(darg) {
63785         (darg)->OnChildRemoveSwigPublic(*arg2);
63786       }
63787     } catch (std::out_of_range& e) {
63788       {
63789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63790       };
63791     } catch (std::exception& e) {
63792       {
63793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63794       };
63795     } catch (Dali::DaliException e) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63798       };
63799     } catch (...) {
63800       {
63801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63802       };
63803     }
63804   }
63805
63806 }
63807
63808
63809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
63810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63811   Dali::Property::Index arg2 ;
63812   Dali::Property::Value arg3 ;
63813   Dali::Property::Value *argp3 ;
63814   SwigDirector_ViewImpl *darg = 0;
63815
63816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63817   arg2 = (Dali::Property::Index)jarg2;
63818   argp3 = (Dali::Property::Value *)jarg3;
63819   if (!argp3) {
63820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
63821     return ;
63822   }
63823   arg3 = *argp3;
63824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63825   if (!darg) {
63826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63827     return;
63828   }
63829   {
63830     try {
63831       (darg)->OnPropertySet(arg2,arg3);
63832     } catch (std::out_of_range& e) {
63833       {
63834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63835       };
63836     } catch (std::exception& e) {
63837       {
63838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63839       };
63840     } catch (Dali::DaliException e) {
63841       {
63842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63843       };
63844     } catch (...) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63847       };
63848     }
63849   }
63850
63851 }
63852
63853
63854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
63855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63856   Dali::Property::Index arg2 ;
63857   Dali::Property::Value arg3 ;
63858   Dali::Property::Value *argp3 ;
63859   SwigDirector_ViewImpl *darg = 0;
63860
63861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63862   arg2 = (Dali::Property::Index)jarg2;
63863   argp3 = (Dali::Property::Value *)jarg3;
63864   if (!argp3) {
63865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
63866     return ;
63867   }
63868   arg3 = *argp3;
63869   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63870   if (!darg) {
63871     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63872     return;
63873   }
63874   {
63875     try {
63876       (darg)->OnPropertySetSwigPublic(arg2,arg3);
63877     } catch (std::out_of_range& e) {
63878       {
63879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63880       };
63881     } catch (std::exception& e) {
63882       {
63883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63884       };
63885     } catch (Dali::DaliException e) {
63886       {
63887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63888       };
63889     } catch (...) {
63890       {
63891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63892       };
63893     }
63894   }
63895
63896 }
63897
63898
63899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
63900   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63901   Dali::Vector3 *arg2 = 0 ;
63902   SwigDirector_ViewImpl *darg = 0;
63903
63904   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63905   arg2 = (Dali::Vector3 *)jarg2;
63906   if (!arg2) {
63907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
63908     return ;
63909   }
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       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
63918     } catch (std::out_of_range& e) {
63919       {
63920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63921       };
63922     } catch (std::exception& e) {
63923       {
63924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63925       };
63926     } catch (Dali::DaliException e) {
63927       {
63928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63929       };
63930     } catch (...) {
63931       {
63932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63933       };
63934     }
63935   }
63936
63937 }
63938
63939
63940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63942   Dali::Vector3 *arg2 = 0 ;
63943   SwigDirector_ViewImpl *darg = 0;
63944
63945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63946   arg2 = (Dali::Vector3 *)jarg2;
63947   if (!arg2) {
63948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
63949     return ;
63950   }
63951   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63952   if (!darg) {
63953     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63954     return;
63955   }
63956   {
63957     try {
63958       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
63959     } catch (std::out_of_range& e) {
63960       {
63961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63962       };
63963     } catch (std::exception& e) {
63964       {
63965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63966       };
63967     } catch (Dali::DaliException e) {
63968       {
63969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63970       };
63971     } catch (...) {
63972       {
63973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63974       };
63975     }
63976   }
63977
63978 }
63979
63980
63981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
63982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63983   Dali::Animation *arg2 = 0 ;
63984   Dali::Vector3 *arg3 = 0 ;
63985   SwigDirector_ViewImpl *darg = 0;
63986
63987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63988   arg2 = (Dali::Animation *)jarg2;
63989   if (!arg2) {
63990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
63991     return ;
63992   }
63993   arg3 = (Dali::Vector3 *)jarg3;
63994   if (!arg3) {
63995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
63996     return ;
63997   }
63998   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63999   if (!darg) {
64000     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64001     return;
64002   }
64003   {
64004     try {
64005       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
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_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64030   Dali::Animation *arg2 = 0 ;
64031   Dali::Vector3 *arg3 = 0 ;
64032   SwigDirector_ViewImpl *darg = 0;
64033
64034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64035   arg2 = (Dali::Animation *)jarg2;
64036   if (!arg2) {
64037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64038     return ;
64039   }
64040   arg3 = (Dali::Vector3 *)jarg3;
64041   if (!arg3) {
64042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64043     return ;
64044   }
64045   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64046   if (!darg) {
64047     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64048     return;
64049   }
64050   {
64051     try {
64052       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64053     } catch (std::out_of_range& e) {
64054       {
64055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64056       };
64057     } catch (std::exception& e) {
64058       {
64059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64060       };
64061     } catch (Dali::DaliException e) {
64062       {
64063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64064       };
64065     } catch (...) {
64066       {
64067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64068       };
64069     }
64070   }
64071
64072 }
64073
64074
64075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64076   unsigned int jresult ;
64077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64078   Dali::TouchEvent *arg2 = 0 ;
64079   SwigDirector_ViewImpl *darg = 0;
64080   bool result;
64081
64082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64083   arg2 = (Dali::TouchEvent *)jarg2;
64084   if (!arg2) {
64085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64086     return 0;
64087   }
64088   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64089   if (!darg) {
64090     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64091     return 0;
64092   }
64093   {
64094     try {
64095       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64096     } catch (std::out_of_range& e) {
64097       {
64098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64099       };
64100     } catch (std::exception& e) {
64101       {
64102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (Dali::DaliException e) {
64105       {
64106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64107       };
64108     } catch (...) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64111       };
64112     }
64113   }
64114
64115   jresult = result;
64116   return jresult;
64117 }
64118
64119
64120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64121   unsigned int jresult ;
64122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64123   Dali::TouchEvent *arg2 = 0 ;
64124   SwigDirector_ViewImpl *darg = 0;
64125   bool result;
64126
64127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64128   arg2 = (Dali::TouchEvent *)jarg2;
64129   if (!arg2) {
64130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64131     return 0;
64132   }
64133   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64134   if (!darg) {
64135     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64136     return 0;
64137   }
64138   {
64139     try {
64140       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64141     } catch (std::out_of_range& e) {
64142       {
64143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64144       };
64145     } catch (std::exception& e) {
64146       {
64147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64148       };
64149     } catch (Dali::DaliException e) {
64150       {
64151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64152       };
64153     } catch (...) {
64154       {
64155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64156       };
64157     }
64158   }
64159
64160   jresult = result;
64161   return jresult;
64162 }
64163
64164
64165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64166   unsigned int jresult ;
64167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64168   Dali::HoverEvent *arg2 = 0 ;
64169   SwigDirector_ViewImpl *darg = 0;
64170   bool result;
64171
64172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64173   arg2 = (Dali::HoverEvent *)jarg2;
64174   if (!arg2) {
64175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64176     return 0;
64177   }
64178   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64179   if (!darg) {
64180     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64181     return 0;
64182   }
64183   {
64184     try {
64185       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64186     } catch (std::out_of_range& e) {
64187       {
64188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64189       };
64190     } catch (std::exception& e) {
64191       {
64192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64193       };
64194     } catch (Dali::DaliException e) {
64195       {
64196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64197       };
64198     } catch (...) {
64199       {
64200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64201       };
64202     }
64203   }
64204
64205   jresult = result;
64206   return jresult;
64207 }
64208
64209
64210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64211   unsigned int jresult ;
64212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64213   Dali::HoverEvent *arg2 = 0 ;
64214   SwigDirector_ViewImpl *darg = 0;
64215   bool result;
64216
64217   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64218   arg2 = (Dali::HoverEvent *)jarg2;
64219   if (!arg2) {
64220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64221     return 0;
64222   }
64223   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64224   if (!darg) {
64225     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64226     return 0;
64227   }
64228   {
64229     try {
64230       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64231     } catch (std::out_of_range& e) {
64232       {
64233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64234       };
64235     } catch (std::exception& e) {
64236       {
64237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64238       };
64239     } catch (Dali::DaliException e) {
64240       {
64241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64242       };
64243     } catch (...) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64246       };
64247     }
64248   }
64249
64250   jresult = result;
64251   return jresult;
64252 }
64253
64254
64255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64256   unsigned int jresult ;
64257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64258   Dali::KeyEvent *arg2 = 0 ;
64259   SwigDirector_ViewImpl *darg = 0;
64260   bool result;
64261
64262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64263   arg2 = (Dali::KeyEvent *)jarg2;
64264   if (!arg2) {
64265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64266     return 0;
64267   }
64268   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64269   if (!darg) {
64270     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64271     return 0;
64272   }
64273   {
64274     try {
64275       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64276     } catch (std::out_of_range& e) {
64277       {
64278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (std::exception& e) {
64281       {
64282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64283       };
64284     } catch (Dali::DaliException e) {
64285       {
64286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64287       };
64288     } catch (...) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64291       };
64292     }
64293   }
64294
64295   jresult = result;
64296   return jresult;
64297 }
64298
64299
64300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64301   unsigned int jresult ;
64302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64303   Dali::KeyEvent *arg2 = 0 ;
64304   SwigDirector_ViewImpl *darg = 0;
64305   bool result;
64306
64307   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64308   arg2 = (Dali::KeyEvent *)jarg2;
64309   if (!arg2) {
64310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64311     return 0;
64312   }
64313   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64314   if (!darg) {
64315     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64316     return 0;
64317   }
64318   {
64319     try {
64320       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64321     } catch (std::out_of_range& e) {
64322       {
64323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (std::exception& e) {
64326       {
64327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64328       };
64329     } catch (Dali::DaliException e) {
64330       {
64331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64332       };
64333     } catch (...) {
64334       {
64335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64336       };
64337     }
64338   }
64339
64340   jresult = result;
64341   return jresult;
64342 }
64343
64344
64345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64346   unsigned int jresult ;
64347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64348   Dali::WheelEvent *arg2 = 0 ;
64349   SwigDirector_ViewImpl *darg = 0;
64350   bool result;
64351
64352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64353   arg2 = (Dali::WheelEvent *)jarg2;
64354   if (!arg2) {
64355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64356     return 0;
64357   }
64358   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64359   if (!darg) {
64360     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64361     return 0;
64362   }
64363   {
64364     try {
64365       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64366     } catch (std::out_of_range& e) {
64367       {
64368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64369       };
64370     } catch (std::exception& e) {
64371       {
64372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64373       };
64374     } catch (Dali::DaliException e) {
64375       {
64376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64377       };
64378     } catch (...) {
64379       {
64380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64381       };
64382     }
64383   }
64384
64385   jresult = result;
64386   return jresult;
64387 }
64388
64389
64390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64391   unsigned int jresult ;
64392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64393   Dali::WheelEvent *arg2 = 0 ;
64394   SwigDirector_ViewImpl *darg = 0;
64395   bool result;
64396
64397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64398   arg2 = (Dali::WheelEvent *)jarg2;
64399   if (!arg2) {
64400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64401     return 0;
64402   }
64403   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64404   if (!darg) {
64405     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64406     return 0;
64407   }
64408   {
64409     try {
64410       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64411     } catch (std::out_of_range& e) {
64412       {
64413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64414       };
64415     } catch (std::exception& e) {
64416       {
64417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64418       };
64419     } catch (Dali::DaliException e) {
64420       {
64421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64422       };
64423     } catch (...) {
64424       {
64425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64426       };
64427     }
64428   }
64429
64430   jresult = result;
64431   return jresult;
64432 }
64433
64434
64435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64437   Dali::Vector2 *arg2 = 0 ;
64438   Dali::RelayoutContainer *arg3 = 0 ;
64439   SwigDirector_ViewImpl *darg = 0;
64440
64441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64442   arg2 = (Dali::Vector2 *)jarg2;
64443   if (!arg2) {
64444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64445     return ;
64446   }
64447   arg3 = (Dali::RelayoutContainer *)jarg3;
64448   if (!arg3) {
64449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64450     return ;
64451   }
64452   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64453   if (!darg) {
64454     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64455     return;
64456   }
64457   {
64458     try {
64459       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64460     } catch (std::out_of_range& e) {
64461       {
64462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64463       };
64464     } catch (std::exception& e) {
64465       {
64466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64467       };
64468     } catch (Dali::DaliException e) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64471       };
64472     } catch (...) {
64473       {
64474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64475       };
64476     }
64477   }
64478
64479 }
64480
64481
64482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64484   Dali::Vector2 *arg2 = 0 ;
64485   Dali::RelayoutContainer *arg3 = 0 ;
64486   SwigDirector_ViewImpl *darg = 0;
64487
64488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64489   arg2 = (Dali::Vector2 *)jarg2;
64490   if (!arg2) {
64491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64492     return ;
64493   }
64494   arg3 = (Dali::RelayoutContainer *)jarg3;
64495   if (!arg3) {
64496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64497     return ;
64498   }
64499   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64500   if (!darg) {
64501     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64502     return;
64503   }
64504   {
64505     try {
64506       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64507     } catch (std::out_of_range& e) {
64508       {
64509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64510       };
64511     } catch (std::exception& e) {
64512       {
64513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64514       };
64515     } catch (Dali::DaliException e) {
64516       {
64517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64518       };
64519     } catch (...) {
64520       {
64521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64522       };
64523     }
64524   }
64525
64526 }
64527
64528
64529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64531   Dali::ResizePolicy::Type arg2 ;
64532   Dali::Dimension::Type arg3 ;
64533   SwigDirector_ViewImpl *darg = 0;
64534
64535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64536   arg2 = (Dali::ResizePolicy::Type)jarg2;
64537   arg3 = (Dali::Dimension::Type)jarg3;
64538   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64539   if (!darg) {
64540     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64541     return;
64542   }
64543   {
64544     try {
64545       (darg)->OnSetResizePolicy(arg2,arg3);
64546     } catch (std::out_of_range& e) {
64547       {
64548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64549       };
64550     } catch (std::exception& e) {
64551       {
64552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64553       };
64554     } catch (Dali::DaliException e) {
64555       {
64556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64557       };
64558     } catch (...) {
64559       {
64560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64561       };
64562     }
64563   }
64564
64565 }
64566
64567
64568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64570   Dali::ResizePolicy::Type arg2 ;
64571   Dali::Dimension::Type arg3 ;
64572   SwigDirector_ViewImpl *darg = 0;
64573
64574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64575   arg2 = (Dali::ResizePolicy::Type)jarg2;
64576   arg3 = (Dali::Dimension::Type)jarg3;
64577   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64578   if (!darg) {
64579     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64580     return;
64581   }
64582   {
64583     try {
64584       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64585     } catch (std::out_of_range& e) {
64586       {
64587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64588       };
64589     } catch (std::exception& e) {
64590       {
64591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64592       };
64593     } catch (Dali::DaliException e) {
64594       {
64595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64596       };
64597     } catch (...) {
64598       {
64599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64600       };
64601     }
64602   }
64603
64604 }
64605
64606
64607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64608   void * jresult ;
64609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64610   SwigDirector_ViewImpl *darg = 0;
64611   Dali::Vector3 result;
64612
64613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64615   if (!darg) {
64616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64617     return 0;
64618   }
64619   {
64620     try {
64621       result = (darg)->GetNaturalSize();
64622     } catch (std::out_of_range& e) {
64623       {
64624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64625       };
64626     } catch (std::exception& e) {
64627       {
64628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64629       };
64630     } catch (Dali::DaliException e) {
64631       {
64632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64633       };
64634     } catch (...) {
64635       {
64636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64637       };
64638     }
64639   }
64640
64641   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64642   return jresult;
64643 }
64644
64645
64646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64647   void * jresult ;
64648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64649   SwigDirector_ViewImpl *darg = 0;
64650   Dali::Vector3 result;
64651
64652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64654   if (!darg) {
64655     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64656     return 0;
64657   }
64658   {
64659     try {
64660       result = (darg)->GetNaturalSizeSwigPublic();
64661     } catch (std::out_of_range& e) {
64662       {
64663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64664       };
64665     } catch (std::exception& e) {
64666       {
64667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64668       };
64669     } catch (Dali::DaliException e) {
64670       {
64671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64672       };
64673     } catch (...) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64676       };
64677     }
64678   }
64679
64680   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64681   return jresult;
64682 }
64683
64684
64685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64686   float jresult ;
64687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64688   Dali::Actor *arg2 = 0 ;
64689   Dali::Dimension::Type arg3 ;
64690   SwigDirector_ViewImpl *darg = 0;
64691   float result;
64692
64693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64694   arg2 = (Dali::Actor *)jarg2;
64695   if (!arg2) {
64696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64697     return 0;
64698   }
64699   arg3 = (Dali::Dimension::Type)jarg3;
64700   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64701   if (!darg) {
64702     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64703     return 0;
64704   }
64705   {
64706     try {
64707       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64708     } catch (std::out_of_range& e) {
64709       {
64710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64711       };
64712     } catch (std::exception& e) {
64713       {
64714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64715       };
64716     } catch (Dali::DaliException e) {
64717       {
64718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64719       };
64720     } catch (...) {
64721       {
64722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64723       };
64724     }
64725   }
64726
64727   jresult = result;
64728   return jresult;
64729 }
64730
64731
64732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64733   float jresult ;
64734   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64735   Dali::Actor *arg2 = 0 ;
64736   Dali::Dimension::Type arg3 ;
64737   SwigDirector_ViewImpl *darg = 0;
64738   float result;
64739
64740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64741   arg2 = (Dali::Actor *)jarg2;
64742   if (!arg2) {
64743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64744     return 0;
64745   }
64746   arg3 = (Dali::Dimension::Type)jarg3;
64747   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64748   if (!darg) {
64749     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64750     return 0;
64751   }
64752   {
64753     try {
64754       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64755     } catch (std::out_of_range& e) {
64756       {
64757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64758       };
64759     } catch (std::exception& e) {
64760       {
64761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64762       };
64763     } catch (Dali::DaliException e) {
64764       {
64765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64766       };
64767     } catch (...) {
64768       {
64769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64770       };
64771     }
64772   }
64773
64774   jresult = result;
64775   return jresult;
64776 }
64777
64778
64779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
64780   float jresult ;
64781   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64782   float arg2 ;
64783   SwigDirector_ViewImpl *darg = 0;
64784   float result;
64785
64786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64787   arg2 = (float)jarg2;
64788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64789   if (!darg) {
64790     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64791     return 0;
64792   }
64793   {
64794     try {
64795       result = (float)(darg)->GetHeightForWidth(arg2);
64796     } catch (std::out_of_range& e) {
64797       {
64798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64799       };
64800     } catch (std::exception& e) {
64801       {
64802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64803       };
64804     } catch (Dali::DaliException e) {
64805       {
64806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64807       };
64808     } catch (...) {
64809       {
64810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64811       };
64812     }
64813   }
64814
64815   jresult = result;
64816   return jresult;
64817 }
64818
64819
64820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
64821   float jresult ;
64822   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64823   float arg2 ;
64824   SwigDirector_ViewImpl *darg = 0;
64825   float result;
64826
64827   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64828   arg2 = (float)jarg2;
64829   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64830   if (!darg) {
64831     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64832     return 0;
64833   }
64834   {
64835     try {
64836       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
64837     } catch (std::out_of_range& e) {
64838       {
64839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64840       };
64841     } catch (std::exception& e) {
64842       {
64843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64844       };
64845     } catch (Dali::DaliException e) {
64846       {
64847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64848       };
64849     } catch (...) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64852       };
64853     }
64854   }
64855
64856   jresult = result;
64857   return jresult;
64858 }
64859
64860
64861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
64862   float jresult ;
64863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64864   float arg2 ;
64865   SwigDirector_ViewImpl *darg = 0;
64866   float result;
64867
64868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64869   arg2 = (float)jarg2;
64870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64871   if (!darg) {
64872     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64873     return 0;
64874   }
64875   {
64876     try {
64877       result = (float)(darg)->GetWidthForHeight(arg2);
64878     } catch (std::out_of_range& e) {
64879       {
64880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64881       };
64882     } catch (std::exception& e) {
64883       {
64884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64885       };
64886     } catch (Dali::DaliException e) {
64887       {
64888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64889       };
64890     } catch (...) {
64891       {
64892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64893       };
64894     }
64895   }
64896
64897   jresult = result;
64898   return jresult;
64899 }
64900
64901
64902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
64903   float jresult ;
64904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64905   float arg2 ;
64906   SwigDirector_ViewImpl *darg = 0;
64907   float result;
64908
64909   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64910   arg2 = (float)jarg2;
64911   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64912   if (!darg) {
64913     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64914     return 0;
64915   }
64916   {
64917     try {
64918       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
64919     } catch (std::out_of_range& e) {
64920       {
64921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64922       };
64923     } catch (std::exception& e) {
64924       {
64925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64926       };
64927     } catch (Dali::DaliException e) {
64928       {
64929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64930       };
64931     } catch (...) {
64932       {
64933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64934       };
64935     }
64936   }
64937
64938   jresult = result;
64939   return jresult;
64940 }
64941
64942
64943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
64944   unsigned int jresult ;
64945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64946   Dali::Dimension::Type arg2 ;
64947   SwigDirector_ViewImpl *darg = 0;
64948   bool result;
64949
64950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64951   arg2 = (Dali::Dimension::Type)jarg2;
64952   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64953   if (!darg) {
64954     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64955     return 0;
64956   }
64957   {
64958     try {
64959       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
64960     } catch (std::out_of_range& e) {
64961       {
64962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (std::exception& e) {
64965       {
64966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64967       };
64968     } catch (Dali::DaliException e) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64971       };
64972     } catch (...) {
64973       {
64974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64975       };
64976     }
64977   }
64978
64979   jresult = result;
64980   return jresult;
64981 }
64982
64983
64984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
64985   unsigned int jresult ;
64986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64987   Dali::Dimension::Type arg2 ;
64988   SwigDirector_ViewImpl *darg = 0;
64989   bool result;
64990
64991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64992   arg2 = (Dali::Dimension::Type)jarg2;
64993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64994   if (!darg) {
64995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64996     return 0;
64997   }
64998   {
64999     try {
65000       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65001     } catch (std::out_of_range& e) {
65002       {
65003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65004       };
65005     } catch (std::exception& e) {
65006       {
65007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65008       };
65009     } catch (Dali::DaliException e) {
65010       {
65011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65012       };
65013     } catch (...) {
65014       {
65015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65016       };
65017     }
65018   }
65019
65020   jresult = result;
65021   return jresult;
65022 }
65023
65024
65025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65026   unsigned int jresult ;
65027   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65028   SwigDirector_ViewImpl *darg = 0;
65029   bool result;
65030
65031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65033   if (!darg) {
65034     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65035     return 0;
65036   }
65037   {
65038     try {
65039       result = (bool)(darg)->RelayoutDependentOnChildren();
65040     } catch (std::out_of_range& e) {
65041       {
65042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65043       };
65044     } catch (std::exception& e) {
65045       {
65046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65047       };
65048     } catch (Dali::DaliException e) {
65049       {
65050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65055       };
65056     }
65057   }
65058
65059   jresult = result;
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65065   unsigned int jresult ;
65066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65067   SwigDirector_ViewImpl *darg = 0;
65068   bool result;
65069
65070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65072   if (!darg) {
65073     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65074     return 0;
65075   }
65076   {
65077     try {
65078       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65079     } catch (std::out_of_range& e) {
65080       {
65081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65082       };
65083     } catch (std::exception& e) {
65084       {
65085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65086       };
65087     } catch (Dali::DaliException e) {
65088       {
65089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65090       };
65091     } catch (...) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65094       };
65095     }
65096   }
65097
65098   jresult = result;
65099   return jresult;
65100 }
65101
65102
65103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65105   Dali::Dimension::Type arg2 ;
65106   SwigDirector_ViewImpl *darg = 0;
65107
65108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65109   arg2 = (Dali::Dimension::Type)jarg2;
65110   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65111   if (!darg) {
65112     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65113     return;
65114   }
65115   {
65116     try {
65117       (darg)->OnCalculateRelayoutSize(arg2);
65118     } catch (std::out_of_range& e) {
65119       {
65120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65121       };
65122     } catch (std::exception& e) {
65123       {
65124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65125       };
65126     } catch (Dali::DaliException e) {
65127       {
65128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65129       };
65130     } catch (...) {
65131       {
65132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65133       };
65134     }
65135   }
65136
65137 }
65138
65139
65140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65142   Dali::Dimension::Type arg2 ;
65143   SwigDirector_ViewImpl *darg = 0;
65144
65145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65146   arg2 = (Dali::Dimension::Type)jarg2;
65147   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65148   if (!darg) {
65149     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65150     return;
65151   }
65152   {
65153     try {
65154       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65155     } catch (std::out_of_range& e) {
65156       {
65157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65158       };
65159     } catch (std::exception& e) {
65160       {
65161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65162       };
65163     } catch (Dali::DaliException e) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65166       };
65167     } catch (...) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65170       };
65171     }
65172   }
65173
65174 }
65175
65176
65177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65179   float arg2 ;
65180   Dali::Dimension::Type arg3 ;
65181   SwigDirector_ViewImpl *darg = 0;
65182
65183   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65184   arg2 = (float)jarg2;
65185   arg3 = (Dali::Dimension::Type)jarg3;
65186   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65187   if (!darg) {
65188     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65189     return;
65190   }
65191   {
65192     try {
65193       (darg)->OnLayoutNegotiated(arg2,arg3);
65194     } catch (std::out_of_range& e) {
65195       {
65196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65197       };
65198     } catch (std::exception& e) {
65199       {
65200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65201       };
65202     } catch (Dali::DaliException e) {
65203       {
65204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65205       };
65206     } catch (...) {
65207       {
65208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65209       };
65210     }
65211   }
65212
65213 }
65214
65215
65216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65218   float arg2 ;
65219   Dali::Dimension::Type arg3 ;
65220   SwigDirector_ViewImpl *darg = 0;
65221
65222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65223   arg2 = (float)jarg2;
65224   arg3 = (Dali::Dimension::Type)jarg3;
65225   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65226   if (!darg) {
65227     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65228     return;
65229   }
65230   {
65231     try {
65232       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65233     } catch (std::out_of_range& e) {
65234       {
65235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65236       };
65237     } catch (std::exception& e) {
65238       {
65239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65240       };
65241     } catch (Dali::DaliException e) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65244       };
65245     } catch (...) {
65246       {
65247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65248       };
65249     }
65250   }
65251
65252 }
65253
65254
65255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65257
65258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65259   {
65260     try {
65261       (arg1)->OnInitialize();
65262     } catch (std::out_of_range& e) {
65263       {
65264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65265       };
65266     } catch (std::exception& e) {
65267       {
65268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65269       };
65270     } catch (Dali::DaliException e) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65273       };
65274     } catch (...) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65277       };
65278     }
65279   }
65280
65281 }
65282
65283
65284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65286
65287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65288   {
65289     try {
65290       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65291     } catch (std::out_of_range& e) {
65292       {
65293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65294       };
65295     } catch (std::exception& e) {
65296       {
65297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65298       };
65299     } catch (Dali::DaliException e) {
65300       {
65301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65302       };
65303     } catch (...) {
65304       {
65305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65306       };
65307     }
65308   }
65309
65310 }
65311
65312
65313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65314   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65315   Dali::Actor *arg2 = 0 ;
65316
65317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65318   arg2 = (Dali::Actor *)jarg2;
65319   if (!arg2) {
65320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65321     return ;
65322   }
65323   {
65324     try {
65325       (arg1)->OnControlChildAdd(*arg2);
65326     } catch (std::out_of_range& e) {
65327       {
65328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65329       };
65330     } catch (std::exception& e) {
65331       {
65332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65333       };
65334     } catch (Dali::DaliException e) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65337       };
65338     } catch (...) {
65339       {
65340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65341       };
65342     }
65343   }
65344
65345 }
65346
65347
65348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65349   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65350   Dali::Actor *arg2 = 0 ;
65351
65352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65353   arg2 = (Dali::Actor *)jarg2;
65354   if (!arg2) {
65355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65356     return ;
65357   }
65358   {
65359     try {
65360       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65361     } catch (std::out_of_range& e) {
65362       {
65363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65364       };
65365     } catch (std::exception& e) {
65366       {
65367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65368       };
65369     } catch (Dali::DaliException e) {
65370       {
65371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65376       };
65377     }
65378   }
65379
65380 }
65381
65382
65383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65385   Dali::Actor *arg2 = 0 ;
65386
65387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65388   arg2 = (Dali::Actor *)jarg2;
65389   if (!arg2) {
65390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65391     return ;
65392   }
65393   {
65394     try {
65395       (arg1)->OnControlChildRemove(*arg2);
65396     } catch (std::out_of_range& e) {
65397       {
65398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65399       };
65400     } catch (std::exception& e) {
65401       {
65402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65403       };
65404     } catch (Dali::DaliException e) {
65405       {
65406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65407       };
65408     } catch (...) {
65409       {
65410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65411       };
65412     }
65413   }
65414
65415 }
65416
65417
65418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65420   Dali::Actor *arg2 = 0 ;
65421
65422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65423   arg2 = (Dali::Actor *)jarg2;
65424   if (!arg2) {
65425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65426     return ;
65427   }
65428   {
65429     try {
65430       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65431     } catch (std::out_of_range& e) {
65432       {
65433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65434       };
65435     } catch (std::exception& e) {
65436       {
65437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65438       };
65439     } catch (Dali::DaliException e) {
65440       {
65441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65442       };
65443     } catch (...) {
65444       {
65445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65446       };
65447     }
65448   }
65449
65450 }
65451
65452
65453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65455   Dali::Toolkit::StyleManager arg2 ;
65456   Dali::StyleChange::Type arg3 ;
65457   Dali::Toolkit::StyleManager *argp2 ;
65458
65459   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65460   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65461   if (!argp2) {
65462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65463     return ;
65464   }
65465   arg2 = *argp2;
65466   arg3 = (Dali::StyleChange::Type)jarg3;
65467   {
65468     try {
65469       (arg1)->OnStyleChange(arg2,arg3);
65470     } catch (std::out_of_range& e) {
65471       {
65472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65473       };
65474     } catch (std::exception& e) {
65475       {
65476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65477       };
65478     } catch (Dali::DaliException e) {
65479       {
65480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65481       };
65482     } catch (...) {
65483       {
65484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65485       };
65486     }
65487   }
65488
65489 }
65490
65491
65492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65493   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65494   Dali::Toolkit::StyleManager arg2 ;
65495   Dali::StyleChange::Type arg3 ;
65496   Dali::Toolkit::StyleManager *argp2 ;
65497
65498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65499   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65500   if (!argp2) {
65501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65502     return ;
65503   }
65504   arg2 = *argp2;
65505   arg3 = (Dali::StyleChange::Type)jarg3;
65506   {
65507     try {
65508       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65509     } catch (std::out_of_range& e) {
65510       {
65511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65512       };
65513     } catch (std::exception& e) {
65514       {
65515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65516       };
65517     } catch (Dali::DaliException e) {
65518       {
65519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65520       };
65521     } catch (...) {
65522       {
65523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65524       };
65525     }
65526   }
65527
65528 }
65529
65530
65531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65532   unsigned int jresult ;
65533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65534   bool result;
65535
65536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65537   {
65538     try {
65539       result = (bool)(arg1)->OnAccessibilityActivated();
65540     } catch (std::out_of_range& e) {
65541       {
65542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65543       };
65544     } catch (std::exception& e) {
65545       {
65546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65547       };
65548     } catch (Dali::DaliException e) {
65549       {
65550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65551       };
65552     } catch (...) {
65553       {
65554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65555       };
65556     }
65557   }
65558
65559   jresult = result;
65560   return jresult;
65561 }
65562
65563
65564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65565   unsigned int jresult ;
65566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65567   bool result;
65568
65569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65570   {
65571     try {
65572       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65573     } catch (std::out_of_range& e) {
65574       {
65575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65576       };
65577     } catch (std::exception& e) {
65578       {
65579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (Dali::DaliException e) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65588       };
65589     }
65590   }
65591
65592   jresult = result;
65593   return jresult;
65594 }
65595
65596
65597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65598   unsigned int jresult ;
65599   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65600   Dali::PanGesture arg2 ;
65601   Dali::PanGesture *argp2 ;
65602   bool result;
65603
65604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65605   argp2 = (Dali::PanGesture *)jarg2;
65606   if (!argp2) {
65607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65608     return 0;
65609   }
65610   arg2 = *argp2;
65611   {
65612     try {
65613       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65614     } catch (std::out_of_range& e) {
65615       {
65616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65617       };
65618     } catch (std::exception& e) {
65619       {
65620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65621       };
65622     } catch (Dali::DaliException e) {
65623       {
65624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65625       };
65626     } catch (...) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65629       };
65630     }
65631   }
65632
65633   jresult = result;
65634   return jresult;
65635 }
65636
65637
65638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65639   unsigned int jresult ;
65640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65641   Dali::PanGesture arg2 ;
65642   Dali::PanGesture *argp2 ;
65643   bool result;
65644
65645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65646   argp2 = (Dali::PanGesture *)jarg2;
65647   if (!argp2) {
65648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65649     return 0;
65650   }
65651   arg2 = *argp2;
65652   {
65653     try {
65654       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65655     } catch (std::out_of_range& e) {
65656       {
65657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65658       };
65659     } catch (std::exception& e) {
65660       {
65661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65662       };
65663     } catch (Dali::DaliException e) {
65664       {
65665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65666       };
65667     } catch (...) {
65668       {
65669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65670       };
65671     }
65672   }
65673
65674   jresult = result;
65675   return jresult;
65676 }
65677
65678
65679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65680   unsigned int jresult ;
65681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65682   Dali::TouchEvent *arg2 = 0 ;
65683   bool result;
65684
65685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65686   arg2 = (Dali::TouchEvent *)jarg2;
65687   if (!arg2) {
65688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65689     return 0;
65690   }
65691   {
65692     try {
65693       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65694     } catch (std::out_of_range& e) {
65695       {
65696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65697       };
65698     } catch (std::exception& e) {
65699       {
65700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65701       };
65702     } catch (Dali::DaliException e) {
65703       {
65704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65705       };
65706     } catch (...) {
65707       {
65708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65709       };
65710     }
65711   }
65712
65713   jresult = result;
65714   return jresult;
65715 }
65716
65717
65718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65719   unsigned int jresult ;
65720   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65721   Dali::TouchEvent *arg2 = 0 ;
65722   bool result;
65723
65724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65725   arg2 = (Dali::TouchEvent *)jarg2;
65726   if (!arg2) {
65727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65728     return 0;
65729   }
65730   {
65731     try {
65732       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65733     } catch (std::out_of_range& e) {
65734       {
65735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65736       };
65737     } catch (std::exception& e) {
65738       {
65739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65740       };
65741     } catch (Dali::DaliException e) {
65742       {
65743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65744       };
65745     } catch (...) {
65746       {
65747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65748       };
65749     }
65750   }
65751
65752   jresult = result;
65753   return jresult;
65754 }
65755
65756
65757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65758   unsigned int jresult ;
65759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65760   bool arg2 ;
65761   bool result;
65762
65763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65764   arg2 = jarg2 ? true : false;
65765   {
65766     try {
65767       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
65768     } catch (std::out_of_range& e) {
65769       {
65770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65771       };
65772     } catch (std::exception& e) {
65773       {
65774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65775       };
65776     } catch (Dali::DaliException e) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65779       };
65780     } catch (...) {
65781       {
65782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65783       };
65784     }
65785   }
65786
65787   jresult = result;
65788   return jresult;
65789 }
65790
65791
65792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
65793   unsigned int jresult ;
65794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65795   bool arg2 ;
65796   bool result;
65797
65798   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65799   arg2 = jarg2 ? true : false;
65800   {
65801     try {
65802       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
65803     } catch (std::out_of_range& e) {
65804       {
65805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65806       };
65807     } catch (std::exception& e) {
65808       {
65809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65810       };
65811     } catch (Dali::DaliException e) {
65812       {
65813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65814       };
65815     } catch (...) {
65816       {
65817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65818       };
65819     }
65820   }
65821
65822   jresult = result;
65823   return jresult;
65824 }
65825
65826
65827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
65828   unsigned int jresult ;
65829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65830   bool result;
65831
65832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65833   {
65834     try {
65835       result = (bool)(arg1)->OnAccessibilityZoom();
65836     } catch (std::out_of_range& e) {
65837       {
65838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65839       };
65840     } catch (std::exception& e) {
65841       {
65842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65843       };
65844     } catch (Dali::DaliException e) {
65845       {
65846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65847       };
65848     } catch (...) {
65849       {
65850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65851       };
65852     }
65853   }
65854
65855   jresult = result;
65856   return jresult;
65857 }
65858
65859
65860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
65861   unsigned int jresult ;
65862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65863   bool result;
65864
65865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65866   {
65867     try {
65868       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
65869     } catch (std::out_of_range& e) {
65870       {
65871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65872       };
65873     } catch (std::exception& e) {
65874       {
65875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65876       };
65877     } catch (Dali::DaliException e) {
65878       {
65879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65880       };
65881     } catch (...) {
65882       {
65883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65884       };
65885     }
65886   }
65887
65888   jresult = result;
65889   return jresult;
65890 }
65891
65892
65893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
65894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65895
65896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65897   {
65898     try {
65899       (arg1)->OnKeyInputFocusGained();
65900     } catch (std::out_of_range& e) {
65901       {
65902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65903       };
65904     } catch (std::exception& e) {
65905       {
65906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65907       };
65908     } catch (Dali::DaliException e) {
65909       {
65910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65911       };
65912     } catch (...) {
65913       {
65914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65915       };
65916     }
65917   }
65918
65919 }
65920
65921
65922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
65923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65924
65925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65926   {
65927     try {
65928       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
65929     } catch (std::out_of_range& e) {
65930       {
65931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65932       };
65933     } catch (std::exception& e) {
65934       {
65935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65936       };
65937     } catch (Dali::DaliException e) {
65938       {
65939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65940       };
65941     } catch (...) {
65942       {
65943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65944       };
65945     }
65946   }
65947
65948 }
65949
65950
65951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
65952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65953
65954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65955   {
65956     try {
65957       (arg1)->OnKeyInputFocusLost();
65958     } catch (std::out_of_range& e) {
65959       {
65960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65961       };
65962     } catch (std::exception& e) {
65963       {
65964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65965       };
65966     } catch (Dali::DaliException e) {
65967       {
65968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65969       };
65970     } catch (...) {
65971       {
65972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65973       };
65974     }
65975   }
65976
65977 }
65978
65979
65980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
65981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65982
65983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65984   {
65985     try {
65986       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
65987     } catch (std::out_of_range& e) {
65988       {
65989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65990       };
65991     } catch (std::exception& e) {
65992       {
65993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65994       };
65995     } catch (Dali::DaliException e) {
65996       {
65997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65998       };
65999     } catch (...) {
66000       {
66001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66002       };
66003     }
66004   }
66005
66006 }
66007
66008
66009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66010   void * jresult ;
66011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66012   Dali::Actor arg2 ;
66013   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66014   bool arg4 ;
66015   Dali::Actor *argp2 ;
66016   Dali::Actor result;
66017
66018   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66019   argp2 = (Dali::Actor *)jarg2;
66020   if (!argp2) {
66021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66022     return 0;
66023   }
66024   arg2 = *argp2;
66025   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66026   arg4 = jarg4 ? true : false;
66027   {
66028     try {
66029       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66037       };
66038     } catch (Dali::DaliException e) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66041       };
66042     } catch (...) {
66043       {
66044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66045       };
66046     }
66047   }
66048
66049   jresult = new Dali::Actor((const Dali::Actor &)result);
66050   return jresult;
66051 }
66052
66053
66054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66055   void * jresult ;
66056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66057   Dali::Actor arg2 ;
66058   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66059   bool arg4 ;
66060   Dali::Actor *argp2 ;
66061   Dali::Actor result;
66062
66063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66064   argp2 = (Dali::Actor *)jarg2;
66065   if (!argp2) {
66066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66067     return 0;
66068   }
66069   arg2 = *argp2;
66070   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66071   arg4 = jarg4 ? true : false;
66072   {
66073     try {
66074       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66075     } catch (std::out_of_range& e) {
66076       {
66077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66078       };
66079     } catch (std::exception& e) {
66080       {
66081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (Dali::DaliException e) {
66084       {
66085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66086       };
66087     } catch (...) {
66088       {
66089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66090       };
66091     }
66092   }
66093
66094   jresult = new Dali::Actor((const Dali::Actor &)result);
66095   return jresult;
66096 }
66097
66098
66099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66101   Dali::Actor arg2 ;
66102   Dali::Actor *argp2 ;
66103
66104   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66105   argp2 = (Dali::Actor *)jarg2;
66106   if (!argp2) {
66107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66108     return ;
66109   }
66110   arg2 = *argp2;
66111   {
66112     try {
66113       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66114     } catch (std::out_of_range& e) {
66115       {
66116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66117       };
66118     } catch (std::exception& e) {
66119       {
66120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66121       };
66122     } catch (Dali::DaliException e) {
66123       {
66124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66125       };
66126     } catch (...) {
66127       {
66128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66129       };
66130     }
66131   }
66132
66133 }
66134
66135
66136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66138   Dali::Actor arg2 ;
66139   Dali::Actor *argp2 ;
66140
66141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66142   argp2 = (Dali::Actor *)jarg2;
66143   if (!argp2) {
66144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66145     return ;
66146   }
66147   arg2 = *argp2;
66148   {
66149     try {
66150       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66151     } catch (std::out_of_range& e) {
66152       {
66153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66154       };
66155     } catch (std::exception& e) {
66156       {
66157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66158       };
66159     } catch (Dali::DaliException e) {
66160       {
66161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66166       };
66167     }
66168   }
66169
66170 }
66171
66172
66173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66174   unsigned int jresult ;
66175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66176   bool result;
66177
66178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66179   {
66180     try {
66181       result = (bool)(arg1)->OnKeyboardEnter();
66182     } catch (std::out_of_range& e) {
66183       {
66184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66185       };
66186     } catch (std::exception& e) {
66187       {
66188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66189       };
66190     } catch (Dali::DaliException e) {
66191       {
66192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66193       };
66194     } catch (...) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66197       };
66198     }
66199   }
66200
66201   jresult = result;
66202   return jresult;
66203 }
66204
66205
66206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66207   unsigned int jresult ;
66208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66209   bool result;
66210
66211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66212   {
66213     try {
66214       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66222       };
66223     } catch (Dali::DaliException e) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66226       };
66227     } catch (...) {
66228       {
66229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66230       };
66231     }
66232   }
66233
66234   jresult = result;
66235   return jresult;
66236 }
66237
66238
66239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66241   Dali::PinchGesture *arg2 = 0 ;
66242
66243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66244   arg2 = (Dali::PinchGesture *)jarg2;
66245   if (!arg2) {
66246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66247     return ;
66248   }
66249   {
66250     try {
66251       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66259       };
66260     } catch (Dali::DaliException e) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66267       };
66268     }
66269   }
66270
66271 }
66272
66273
66274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66276   Dali::PinchGesture *arg2 = 0 ;
66277
66278   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66279   arg2 = (Dali::PinchGesture *)jarg2;
66280   if (!arg2) {
66281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66282     return ;
66283   }
66284   {
66285     try {
66286       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66287     } catch (std::out_of_range& e) {
66288       {
66289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66290       };
66291     } catch (std::exception& e) {
66292       {
66293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66294       };
66295     } catch (Dali::DaliException e) {
66296       {
66297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66298       };
66299     } catch (...) {
66300       {
66301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66302       };
66303     }
66304   }
66305
66306 }
66307
66308
66309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66310   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66311   Dali::PanGesture *arg2 = 0 ;
66312
66313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66314   arg2 = (Dali::PanGesture *)jarg2;
66315   if (!arg2) {
66316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66317     return ;
66318   }
66319   {
66320     try {
66321       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66322     } catch (std::out_of_range& e) {
66323       {
66324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66325       };
66326     } catch (std::exception& e) {
66327       {
66328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66329       };
66330     } catch (Dali::DaliException e) {
66331       {
66332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66333       };
66334     } catch (...) {
66335       {
66336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66337       };
66338     }
66339   }
66340
66341 }
66342
66343
66344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66346   Dali::PanGesture *arg2 = 0 ;
66347
66348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66349   arg2 = (Dali::PanGesture *)jarg2;
66350   if (!arg2) {
66351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66352     return ;
66353   }
66354   {
66355     try {
66356       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66357     } catch (std::out_of_range& e) {
66358       {
66359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66360       };
66361     } catch (std::exception& e) {
66362       {
66363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66364       };
66365     } catch (Dali::DaliException e) {
66366       {
66367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66368       };
66369     } catch (...) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66372       };
66373     }
66374   }
66375
66376 }
66377
66378
66379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66381   Dali::TapGesture *arg2 = 0 ;
66382
66383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66384   arg2 = (Dali::TapGesture *)jarg2;
66385   if (!arg2) {
66386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66387     return ;
66388   }
66389   {
66390     try {
66391       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66392     } catch (std::out_of_range& e) {
66393       {
66394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66395       };
66396     } catch (std::exception& e) {
66397       {
66398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66399       };
66400     } catch (Dali::DaliException e) {
66401       {
66402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66403       };
66404     } catch (...) {
66405       {
66406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66407       };
66408     }
66409   }
66410
66411 }
66412
66413
66414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66416   Dali::TapGesture *arg2 = 0 ;
66417
66418   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66419   arg2 = (Dali::TapGesture *)jarg2;
66420   if (!arg2) {
66421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66422     return ;
66423   }
66424   {
66425     try {
66426       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66427     } catch (std::out_of_range& e) {
66428       {
66429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66430       };
66431     } catch (std::exception& e) {
66432       {
66433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66434       };
66435     } catch (Dali::DaliException e) {
66436       {
66437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66438       };
66439     } catch (...) {
66440       {
66441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66442       };
66443     }
66444   }
66445
66446 }
66447
66448
66449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66451   Dali::LongPressGesture *arg2 = 0 ;
66452
66453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66454   arg2 = (Dali::LongPressGesture *)jarg2;
66455   if (!arg2) {
66456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66457     return ;
66458   }
66459   {
66460     try {
66461       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66462     } catch (std::out_of_range& e) {
66463       {
66464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66465       };
66466     } catch (std::exception& e) {
66467       {
66468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66469       };
66470     } catch (Dali::DaliException e) {
66471       {
66472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66473       };
66474     } catch (...) {
66475       {
66476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66477       };
66478     }
66479   }
66480
66481 }
66482
66483
66484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66486   Dali::LongPressGesture *arg2 = 0 ;
66487
66488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66489   arg2 = (Dali::LongPressGesture *)jarg2;
66490   if (!arg2) {
66491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66492     return ;
66493   }
66494   {
66495     try {
66496       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66497     } catch (std::out_of_range& e) {
66498       {
66499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66500       };
66501     } catch (std::exception& e) {
66502       {
66503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66504       };
66505     } catch (Dali::DaliException e) {
66506       {
66507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66508       };
66509     } catch (...) {
66510       {
66511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66512       };
66513     }
66514   }
66515
66516 }
66517
66518
66519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66520   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66521   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66522   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66523
66524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66525   arg2 = (Dali::SlotObserver *)jarg2;
66526   arg3 = (Dali::CallbackBase *)jarg3;
66527   {
66528     try {
66529       (arg1)->SignalConnected(arg2,arg3);
66530     } catch (std::out_of_range& e) {
66531       {
66532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (std::exception& e) {
66535       {
66536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66537       };
66538     } catch (Dali::DaliException e) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66541       };
66542     } catch (...) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66545       };
66546     }
66547   }
66548
66549 }
66550
66551
66552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66554   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66555   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66556
66557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66558   arg2 = (Dali::SlotObserver *)jarg2;
66559   arg3 = (Dali::CallbackBase *)jarg3;
66560   {
66561     try {
66562       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66563     } catch (std::out_of_range& e) {
66564       {
66565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66566       };
66567     } catch (std::exception& e) {
66568       {
66569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66570       };
66571     } catch (Dali::DaliException e) {
66572       {
66573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66574       };
66575     } catch (...) {
66576       {
66577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66578       };
66579     }
66580   }
66581
66582 }
66583
66584
66585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66587   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66588   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66589
66590   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66591   arg2 = (Dali::SlotObserver *)jarg2;
66592   arg3 = (Dali::CallbackBase *)jarg3;
66593   {
66594     try {
66595       (arg1)->SignalDisconnected(arg2,arg3);
66596     } catch (std::out_of_range& e) {
66597       {
66598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66599       };
66600     } catch (std::exception& e) {
66601       {
66602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66603       };
66604     } catch (Dali::DaliException e) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66607       };
66608     } catch (...) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66611       };
66612     }
66613   }
66614
66615 }
66616
66617
66618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66619   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66620   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66621   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66622
66623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66624   arg2 = (Dali::SlotObserver *)jarg2;
66625   arg3 = (Dali::CallbackBase *)jarg3;
66626   {
66627     try {
66628       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66629     } catch (std::out_of_range& e) {
66630       {
66631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66632       };
66633     } catch (std::exception& e) {
66634       {
66635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66636       };
66637     } catch (Dali::DaliException e) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66640       };
66641     } catch (...) {
66642       {
66643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66644       };
66645     }
66646   }
66647
66648 }
66649
66650
66651 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) {
66652   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66653   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66654   if (director) {
66655     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);
66656   }
66657 }
66658
66659
66660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66661   void * jresult ;
66662   Dali::Toolkit::Control *arg1 = 0 ;
66663   Dali::Toolkit::Internal::Control *result = 0 ;
66664
66665   arg1 = (Dali::Toolkit::Control *)jarg1;
66666   if (!arg1) {
66667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66668     return 0;
66669   }
66670   {
66671     try {
66672       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66673     } catch (std::out_of_range& e) {
66674       {
66675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66676       };
66677     } catch (std::exception& e) {
66678       {
66679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66680       };
66681     } catch (Dali::DaliException e) {
66682       {
66683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66684       };
66685     } catch (...) {
66686       {
66687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66688       };
66689     }
66690   }
66691
66692   jresult = (void *)result;
66693   return jresult;
66694 }
66695
66696
66697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66698   int jresult ;
66699   int result;
66700
66701   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66702   jresult = (int)result;
66703   return jresult;
66704 }
66705
66706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66707   int jresult ;
66708   int result;
66709
66710   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66711   jresult = (int)result;
66712   return jresult;
66713 }
66714
66715
66716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66717   int jresult ;
66718   int result;
66719
66720   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66721   jresult = (int)result;
66722   return jresult;
66723 }
66724
66725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66726   int jresult ;
66727   int result;
66728
66729   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66730   jresult = (int)result;
66731   return jresult;
66732 }
66733
66734
66735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66736   int jresult ;
66737   int result;
66738
66739   result = (int)Dali::Toolkit::Control::Property::PADDING;
66740   jresult = (int)result;
66741   return jresult;
66742 }
66743
66744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
66745   int jresult ;
66746   int result;
66747
66748   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
66749   jresult = (int)result;
66750   return jresult;
66751 }
66752
66753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66754   void * jresult ;
66755   Dali::Toolkit::Control::Property *result = 0 ;
66756
66757   {
66758     try {
66759       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66760     } catch (std::out_of_range& e) {
66761       {
66762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66763       };
66764     } catch (std::exception& e) {
66765       {
66766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66767       };
66768     } catch (Dali::DaliException e) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66771       };
66772     } catch (...) {
66773       {
66774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66775       };
66776     }
66777   }
66778
66779   jresult = (void *)result;
66780   return jresult;
66781 }
66782
66783
66784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
66785   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
66786
66787   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
66788   {
66789     try {
66790       delete arg1;
66791     } catch (std::out_of_range& e) {
66792       {
66793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66794       };
66795     } catch (std::exception& e) {
66796       {
66797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66798       };
66799     } catch (Dali::DaliException e) {
66800       {
66801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66802       };
66803     } catch (...) {
66804       {
66805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66806       };
66807     }
66808   }
66809
66810 }
66811
66812
66813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
66814   void * jresult ;
66815   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
66816
66817   {
66818     try {
66819       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
66820     } catch (std::out_of_range& e) {
66821       {
66822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66823       };
66824     } catch (std::exception& e) {
66825       {
66826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66827       };
66828     } catch (Dali::DaliException e) {
66829       {
66830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66831       };
66832     } catch (...) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66835       };
66836     }
66837   }
66838
66839   jresult = (void *)result;
66840   return jresult;
66841 }
66842
66843
66844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
66845   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
66846
66847   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
66848   {
66849     try {
66850       delete arg1;
66851     } catch (std::out_of_range& e) {
66852       {
66853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66854       };
66855     } catch (std::exception& e) {
66856       {
66857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66858       };
66859     } catch (Dali::DaliException e) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66862       };
66863     } catch (...) {
66864       {
66865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66866       };
66867     }
66868   }
66869
66870 }
66871
66872
66873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
66874   void * jresult ;
66875   Dali::Toolkit::Control result;
66876
66877   {
66878     try {
66879       result = Dali::Toolkit::Control::New();
66880     } catch (std::out_of_range& e) {
66881       {
66882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66883       };
66884     } catch (std::exception& e) {
66885       {
66886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (Dali::DaliException e) {
66889       {
66890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66891       };
66892     } catch (...) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66895       };
66896     }
66897   }
66898
66899   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
66900   return jresult;
66901 }
66902
66903
66904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
66905   void * jresult ;
66906   Dali::Toolkit::Control *result = 0 ;
66907
66908   {
66909     try {
66910       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
66911     } catch (std::out_of_range& e) {
66912       {
66913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66914       };
66915     } catch (std::exception& e) {
66916       {
66917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66918       };
66919     } catch (Dali::DaliException e) {
66920       {
66921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66922       };
66923     } catch (...) {
66924       {
66925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66926       };
66927     }
66928   }
66929
66930   jresult = (void *)result;
66931   return jresult;
66932 }
66933
66934
66935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
66936   void * jresult ;
66937   Dali::Toolkit::Control *arg1 = 0 ;
66938   Dali::Toolkit::Control *result = 0 ;
66939
66940   arg1 = (Dali::Toolkit::Control *)jarg1;
66941   if (!arg1) {
66942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
66943     return 0;
66944   }
66945   {
66946     try {
66947       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
66948     } catch (std::out_of_range& e) {
66949       {
66950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66951       };
66952     } catch (std::exception& e) {
66953       {
66954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66955       };
66956     } catch (Dali::DaliException e) {
66957       {
66958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66959       };
66960     } catch (...) {
66961       {
66962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66963       };
66964     }
66965   }
66966
66967   jresult = (void *)result;
66968   return jresult;
66969 }
66970
66971
66972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
66973   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66974
66975   arg1 = (Dali::Toolkit::Control *)jarg1;
66976   {
66977     try {
66978       delete arg1;
66979     } catch (std::out_of_range& e) {
66980       {
66981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66982       };
66983     } catch (std::exception& e) {
66984       {
66985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66986       };
66987     } catch (Dali::DaliException e) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66990       };
66991     } catch (...) {
66992       {
66993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66994       };
66995     }
66996   }
66997
66998 }
66999
67000
67001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67002   void * jresult ;
67003   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67004   Dali::Toolkit::Control *arg2 = 0 ;
67005   Dali::Toolkit::Control *result = 0 ;
67006
67007   arg1 = (Dali::Toolkit::Control *)jarg1;
67008   arg2 = (Dali::Toolkit::Control *)jarg2;
67009   if (!arg2) {
67010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67011     return 0;
67012   }
67013   {
67014     try {
67015       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67016     } catch (std::out_of_range& e) {
67017       {
67018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67019       };
67020     } catch (std::exception& e) {
67021       {
67022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67023       };
67024     } catch (Dali::DaliException e) {
67025       {
67026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67027       };
67028     } catch (...) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67031       };
67032     }
67033   }
67034
67035   jresult = (void *)result;
67036   return jresult;
67037 }
67038
67039
67040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67041   void * jresult ;
67042   Dali::BaseHandle arg1 ;
67043   Dali::BaseHandle *argp1 ;
67044   Dali::Toolkit::Control result;
67045
67046   argp1 = (Dali::BaseHandle *)jarg1;
67047   if (!argp1) {
67048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67049     return 0;
67050   }
67051   arg1 = *argp1;
67052   {
67053     try {
67054       result = Dali::Toolkit::Control::DownCast(arg1);
67055     } catch (std::out_of_range& e) {
67056       {
67057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67058       };
67059     } catch (std::exception& e) {
67060       {
67061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67062       };
67063     } catch (Dali::DaliException e) {
67064       {
67065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67066       };
67067     } catch (...) {
67068       {
67069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67070       };
67071     }
67072   }
67073
67074   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67075   return jresult;
67076 }
67077
67078
67079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67080   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67081
67082   arg1 = (Dali::Toolkit::Control *)jarg1;
67083   {
67084     try {
67085       (arg1)->SetKeyInputFocus();
67086     } catch (std::out_of_range& e) {
67087       {
67088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67089       };
67090     } catch (std::exception& e) {
67091       {
67092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67093       };
67094     } catch (Dali::DaliException e) {
67095       {
67096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67097       };
67098     } catch (...) {
67099       {
67100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67101       };
67102     }
67103   }
67104
67105 }
67106
67107
67108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67109   unsigned int jresult ;
67110   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67111   bool result;
67112
67113   arg1 = (Dali::Toolkit::Control *)jarg1;
67114   {
67115     try {
67116       result = (bool)(arg1)->HasKeyInputFocus();
67117     } catch (std::out_of_range& e) {
67118       {
67119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67120       };
67121     } catch (std::exception& e) {
67122       {
67123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67124       };
67125     } catch (Dali::DaliException e) {
67126       {
67127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67128       };
67129     } catch (...) {
67130       {
67131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67132       };
67133     }
67134   }
67135
67136   jresult = result;
67137   return jresult;
67138 }
67139
67140
67141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67142   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67143
67144   arg1 = (Dali::Toolkit::Control *)jarg1;
67145   {
67146     try {
67147       (arg1)->ClearKeyInputFocus();
67148     } catch (std::out_of_range& e) {
67149       {
67150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67151       };
67152     } catch (std::exception& e) {
67153       {
67154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67155       };
67156     } catch (Dali::DaliException e) {
67157       {
67158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67159       };
67160     } catch (...) {
67161       {
67162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67163       };
67164     }
67165   }
67166
67167 }
67168
67169
67170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67171   void * jresult ;
67172   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67173   Dali::PinchGestureDetector result;
67174
67175   arg1 = (Dali::Toolkit::Control *)jarg1;
67176   {
67177     try {
67178       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67179     } catch (std::out_of_range& e) {
67180       {
67181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (std::exception& e) {
67184       {
67185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67186       };
67187     } catch (Dali::DaliException e) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67190       };
67191     } catch (...) {
67192       {
67193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67194       };
67195     }
67196   }
67197
67198   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67199   return jresult;
67200 }
67201
67202
67203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67204   void * jresult ;
67205   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67206   Dali::PanGestureDetector result;
67207
67208   arg1 = (Dali::Toolkit::Control *)jarg1;
67209   {
67210     try {
67211       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67212     } catch (std::out_of_range& e) {
67213       {
67214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67215       };
67216     } catch (std::exception& e) {
67217       {
67218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67219       };
67220     } catch (Dali::DaliException e) {
67221       {
67222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67223       };
67224     } catch (...) {
67225       {
67226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67227       };
67228     }
67229   }
67230
67231   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67232   return jresult;
67233 }
67234
67235
67236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67237   void * jresult ;
67238   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67239   Dali::TapGestureDetector result;
67240
67241   arg1 = (Dali::Toolkit::Control *)jarg1;
67242   {
67243     try {
67244       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67245     } catch (std::out_of_range& e) {
67246       {
67247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67248       };
67249     } catch (std::exception& e) {
67250       {
67251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67252       };
67253     } catch (Dali::DaliException e) {
67254       {
67255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67256       };
67257     } catch (...) {
67258       {
67259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67260       };
67261     }
67262   }
67263
67264   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67265   return jresult;
67266 }
67267
67268
67269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67270   void * jresult ;
67271   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67272   Dali::LongPressGestureDetector result;
67273
67274   arg1 = (Dali::Toolkit::Control *)jarg1;
67275   {
67276     try {
67277       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67278     } catch (std::out_of_range& e) {
67279       {
67280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (std::exception& e) {
67283       {
67284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67285       };
67286     } catch (Dali::DaliException e) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67289       };
67290     } catch (...) {
67291       {
67292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67293       };
67294     }
67295   }
67296
67297   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67298   return jresult;
67299 }
67300
67301
67302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67303   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67304   std::string *arg2 = 0 ;
67305
67306   arg1 = (Dali::Toolkit::Control *)jarg1;
67307   if (!jarg2) {
67308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67309     return ;
67310   }
67311   std::string arg2_str(jarg2);
67312   arg2 = &arg2_str;
67313   {
67314     try {
67315       (arg1)->SetStyleName((std::string const &)*arg2);
67316     } catch (std::out_of_range& e) {
67317       {
67318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67319       };
67320     } catch (std::exception& e) {
67321       {
67322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67323       };
67324     } catch (Dali::DaliException e) {
67325       {
67326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67327       };
67328     } catch (...) {
67329       {
67330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67331       };
67332     }
67333   }
67334
67335
67336   //argout typemap for const std::string&
67337
67338 }
67339
67340
67341 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67342   char * jresult ;
67343   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67344   std::string *result = 0 ;
67345
67346   arg1 = (Dali::Toolkit::Control *)jarg1;
67347   {
67348     try {
67349       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67350     } catch (std::out_of_range& e) {
67351       {
67352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67353       };
67354     } catch (std::exception& e) {
67355       {
67356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67357       };
67358     } catch (Dali::DaliException e) {
67359       {
67360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67361       };
67362     } catch (...) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67365       };
67366     }
67367   }
67368
67369   jresult = SWIG_csharp_string_callback(result->c_str());
67370   return jresult;
67371 }
67372
67373
67374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67375   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67376   Dali::Vector4 *arg2 = 0 ;
67377
67378   arg1 = (Dali::Toolkit::Control *)jarg1;
67379   arg2 = (Dali::Vector4 *)jarg2;
67380   if (!arg2) {
67381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67382     return ;
67383   }
67384   {
67385     try {
67386       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67387     } catch (std::out_of_range& e) {
67388       {
67389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67390       };
67391     } catch (std::exception& e) {
67392       {
67393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67394       };
67395     } catch (Dali::DaliException e) {
67396       {
67397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67398       };
67399     } catch (...) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67402       };
67403     }
67404   }
67405
67406 }
67407
67408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67409   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67410
67411   arg1 = (Dali::Toolkit::Control *)jarg1;
67412   {
67413     try {
67414       (arg1)->ClearBackground();
67415     } catch (std::out_of_range& e) {
67416       {
67417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67418       };
67419     } catch (std::exception& e) {
67420       {
67421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67422       };
67423     } catch (Dali::DaliException e) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67426       };
67427     } catch (...) {
67428       {
67429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67430       };
67431     }
67432   }
67433
67434 }
67435
67436
67437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67438   void * jresult ;
67439   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67440   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67441
67442   arg1 = (Dali::Toolkit::Control *)jarg1;
67443   {
67444     try {
67445       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (Dali::DaliException e) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67457       };
67458     } catch (...) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67461       };
67462     }
67463   }
67464
67465   jresult = (void *)result;
67466   return jresult;
67467 }
67468
67469
67470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67471   void * jresult ;
67472   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67473   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67474
67475   arg1 = (Dali::Toolkit::Control *)jarg1;
67476   {
67477     try {
67478       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67479     } catch (std::out_of_range& e) {
67480       {
67481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67482       };
67483     } catch (std::exception& e) {
67484       {
67485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67486       };
67487     } catch (Dali::DaliException e) {
67488       {
67489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67490       };
67491     } catch (...) {
67492       {
67493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67494       };
67495     }
67496   }
67497
67498   jresult = (void *)result;
67499   return jresult;
67500 }
67501
67502
67503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67504   void * jresult ;
67505   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67506   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67507
67508   arg1 = (Dali::Toolkit::Control *)jarg1;
67509   {
67510     try {
67511       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67512     } catch (std::out_of_range& e) {
67513       {
67514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67515       };
67516     } catch (std::exception& e) {
67517       {
67518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67519       };
67520     } catch (Dali::DaliException e) {
67521       {
67522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67523       };
67524     } catch (...) {
67525       {
67526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67527       };
67528     }
67529   }
67530
67531   jresult = (void *)result;
67532   return jresult;
67533 }
67534
67535
67536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67537   void * jresult ;
67538   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67539   Dali::Toolkit::Control *result = 0 ;
67540
67541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67542   if (!arg1) {
67543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67544     return 0;
67545   }
67546   {
67547     try {
67548       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67549     } catch (std::out_of_range& e) {
67550       {
67551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67552       };
67553     } catch (std::exception& e) {
67554       {
67555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67556       };
67557     } catch (Dali::DaliException e) {
67558       {
67559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67560       };
67561     } catch (...) {
67562       {
67563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67564       };
67565     }
67566   }
67567
67568   jresult = (void *)result;
67569   return jresult;
67570 }
67571
67572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67573 {
67574   int jresult;
67575   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67576   arg1 = (Dali::Toolkit::Control *)jarg1;
67577
67578   if (!arg1) {
67579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67580     return 0;
67581   }
67582
67583   Dali::Property::Index arg2 = 0 ;
67584   arg2 = (Dali::Property::Index)jarg2;
67585
67586   Toolkit::Visual::ResourceStatus result;
67587   {
67588     try {
67589       result = arg1->GetVisualResourceStatus(arg2);
67590     } catch (std::out_of_range& e) {
67591       {
67592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67593       };
67594     } catch (std::exception& e) {
67595       {
67596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67597       };
67598     } catch (...) {
67599       {
67600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67601       };
67602     }
67603   }
67604   jresult = (int)(result);
67605   return jresult;
67606 }
67607
67608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67609 {
67610   void * jresult;
67611   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67612   arg1 = (Dali::Toolkit::Control *)jarg1;
67613
67614   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67615
67616   Dali::Toolkit::TransitionData *arg2 = 0 ;
67617   Dali::Animation result;
67618
67619   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67620   if (!arg2) {
67621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67622     return 0;
67623   }
67624   {
67625     try {
67626       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67627     } catch (std::out_of_range& e) {
67628       {
67629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67630       };
67631     } catch (std::exception& e) {
67632       {
67633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67634       };
67635     } catch (Dali::DaliException e) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67638       };
67639     } catch (...) {
67640       {
67641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67642       };
67643     }
67644   }
67645
67646   jresult = new Dali::Animation((const Dali::Animation &)result);
67647   return jresult;
67648 }
67649
67650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67651 {
67652   Dali::Toolkit::Control arg1;
67653   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67654
67655   if (!argp1) {
67656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67657   }
67658   arg1 = *argp1;
67659
67660   Dali::Property::Index arg2 = 0 ;
67661   arg2 = (Dali::Property::Index)jarg2;
67662
67663   Dali::Property::Index arg3 = 0 ;
67664   arg3 = (Dali::Property::Index)jarg3;
67665
67666   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67667
67668   {
67669     try {
67670       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67671     } catch (std::out_of_range& e) {
67672       {
67673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67674       };
67675     } catch (std::exception& e) {
67676       {
67677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67678       };
67679     } catch (...) {
67680       {
67681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67682       };
67683     }
67684   }
67685
67686
67687 }
67688
67689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67690   void * jresult ;
67691   Dali::Toolkit::Control *arg1 = 0 ;
67692   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67693
67694   arg1 = (Dali::Toolkit::Control *)jarg1;
67695   if (!arg1) {
67696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67697     return 0;
67698   }
67699   {
67700     try {
67701       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67702     } catch (std::out_of_range& e) {
67703       {
67704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67705       };
67706     } catch (std::exception& e) {
67707       {
67708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67709       };
67710     } catch (Dali::DaliException e) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67713       };
67714     } catch (...) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67717       };
67718     }
67719   }
67720
67721   jresult = (void *)result;
67722   return jresult;
67723 }
67724
67725
67726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
67727   unsigned int jresult ;
67728   Dali::Toolkit::Control *arg1 = 0 ;
67729   bool result;
67730
67731   arg1 = (Dali::Toolkit::Control *)jarg1;
67732   if (!arg1) {
67733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67734     return 0;
67735   }
67736   {
67737     try {
67738       result = (bool)arg1->IsResourceReady();
67739     } catch (std::out_of_range& e) {
67740       {
67741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67742       };
67743     } catch (std::exception& e) {
67744       {
67745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67746       };
67747     } catch (Dali::DaliException e) {
67748       {
67749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67750       };
67751     } catch (...) {
67752       {
67753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67754       };
67755     }
67756   }
67757
67758   jresult = result;
67759   return jresult;
67760 }
67761
67762
67763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
67764   void * jresult ;
67765   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
67766
67767   {
67768     try {
67769       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
67770     } catch (std::out_of_range& e) {
67771       {
67772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67773       };
67774     } catch (std::exception& e) {
67775       {
67776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67777       };
67778     } catch (Dali::DaliException e) {
67779       {
67780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67781       };
67782     } catch (...) {
67783       {
67784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67785       };
67786     }
67787   }
67788
67789   jresult = (void *)result;
67790   return jresult;
67791 }
67792
67793
67794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
67795   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
67796
67797   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
67798   {
67799     try {
67800       delete arg1;
67801     } catch (std::out_of_range& e) {
67802       {
67803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67804       };
67805     } catch (std::exception& e) {
67806       {
67807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67808       };
67809     } catch (Dali::DaliException e) {
67810       {
67811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67812       };
67813     } catch (...) {
67814       {
67815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67816       };
67817     }
67818   }
67819
67820 }
67821
67822
67823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
67824   void * jresult ;
67825   Dali::Toolkit::KeyInputFocusManager result;
67826
67827   {
67828     try {
67829       result = Dali::Toolkit::KeyInputFocusManager::Get();
67830     } catch (std::out_of_range& e) {
67831       {
67832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67833       };
67834     } catch (std::exception& e) {
67835       {
67836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (Dali::DaliException e) {
67839       {
67840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67841       };
67842     } catch (...) {
67843       {
67844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67845       };
67846     }
67847   }
67848
67849   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
67850   return jresult;
67851 }
67852
67853
67854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
67855   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
67856   Dali::Toolkit::Control arg2 ;
67857   Dali::Toolkit::Control *argp2 ;
67858
67859   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
67860   argp2 = (Dali::Toolkit::Control *)jarg2;
67861   if (!argp2) {
67862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
67863     return ;
67864   }
67865   arg2 = *argp2;
67866   {
67867     try {
67868       (arg1)->SetFocus(arg2);
67869     } catch (std::out_of_range& e) {
67870       {
67871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67872       };
67873     } catch (std::exception& e) {
67874       {
67875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67876       };
67877     } catch (Dali::DaliException e) {
67878       {
67879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67880       };
67881     } catch (...) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67884       };
67885     }
67886   }
67887
67888 }
67889
67890
67891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
67892   void * jresult ;
67893   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
67894   Dali::Toolkit::Control result;
67895
67896   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
67897   {
67898     try {
67899       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
67900     } catch (std::out_of_range& e) {
67901       {
67902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67903       };
67904     } catch (std::exception& e) {
67905       {
67906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67907       };
67908     } catch (Dali::DaliException e) {
67909       {
67910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67911       };
67912     } catch (...) {
67913       {
67914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67915       };
67916     }
67917   }
67918
67919   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67920   return jresult;
67921 }
67922
67923
67924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
67925   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
67926   Dali::Toolkit::Control arg2 ;
67927   Dali::Toolkit::Control *argp2 ;
67928
67929   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
67930   argp2 = (Dali::Toolkit::Control *)jarg2;
67931   if (!argp2) {
67932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
67933     return ;
67934   }
67935   arg2 = *argp2;
67936   {
67937     try {
67938       (arg1)->RemoveFocus(arg2);
67939     } catch (std::out_of_range& e) {
67940       {
67941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67942       };
67943     } catch (std::exception& e) {
67944       {
67945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67946       };
67947     } catch (Dali::DaliException e) {
67948       {
67949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67950       };
67951     } catch (...) {
67952       {
67953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67954       };
67955     }
67956   }
67957
67958 }
67959
67960
67961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
67962   void * jresult ;
67963   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
67964   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
67965
67966   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
67967   {
67968     try {
67969       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
67970     } catch (std::out_of_range& e) {
67971       {
67972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67973       };
67974     } catch (std::exception& e) {
67975       {
67976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67977       };
67978     } catch (Dali::DaliException e) {
67979       {
67980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67981       };
67982     } catch (...) {
67983       {
67984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67985       };
67986     }
67987   }
67988
67989   jresult = (void *)result;
67990   return jresult;
67991 }
67992
67993
67994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
67995   void * jresult ;
67996   Dali::Toolkit::Alignment::Padding *result = 0 ;
67997
67998   {
67999     try {
68000       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68001     } catch (std::out_of_range& e) {
68002       {
68003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68004       };
68005     } catch (std::exception& e) {
68006       {
68007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68008       };
68009     } catch (Dali::DaliException e) {
68010       {
68011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68012       };
68013     } catch (...) {
68014       {
68015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68016       };
68017     }
68018   }
68019
68020   jresult = (void *)result;
68021   return jresult;
68022 }
68023
68024
68025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68026   void * jresult ;
68027   float arg1 ;
68028   float arg2 ;
68029   float arg3 ;
68030   float arg4 ;
68031   Dali::Toolkit::Alignment::Padding *result = 0 ;
68032
68033   arg1 = (float)jarg1;
68034   arg2 = (float)jarg2;
68035   arg3 = (float)jarg3;
68036   arg4 = (float)jarg4;
68037   {
68038     try {
68039       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68040     } catch (std::out_of_range& e) {
68041       {
68042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68043       };
68044     } catch (std::exception& e) {
68045       {
68046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68047       };
68048     } catch (Dali::DaliException e) {
68049       {
68050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68051       };
68052     } catch (...) {
68053       {
68054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68055       };
68056     }
68057   }
68058
68059   jresult = (void *)result;
68060   return jresult;
68061 }
68062
68063
68064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68065   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68066   float arg2 ;
68067
68068   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68069   arg2 = (float)jarg2;
68070   if (arg1) (arg1)->left = arg2;
68071 }
68072
68073
68074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68075   float jresult ;
68076   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68077   float result;
68078
68079   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68080   result = (float) ((arg1)->left);
68081   jresult = result;
68082   return jresult;
68083 }
68084
68085
68086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68087   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68088   float arg2 ;
68089
68090   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68091   arg2 = (float)jarg2;
68092   if (arg1) (arg1)->right = arg2;
68093 }
68094
68095
68096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68097   float jresult ;
68098   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68099   float result;
68100
68101   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68102   result = (float) ((arg1)->right);
68103   jresult = result;
68104   return jresult;
68105 }
68106
68107
68108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68109   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68110   float arg2 ;
68111
68112   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68113   arg2 = (float)jarg2;
68114   if (arg1) (arg1)->top = arg2;
68115 }
68116
68117
68118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68119   float jresult ;
68120   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68121   float result;
68122
68123   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68124   result = (float) ((arg1)->top);
68125   jresult = result;
68126   return jresult;
68127 }
68128
68129
68130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68131   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68132   float arg2 ;
68133
68134   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68135   arg2 = (float)jarg2;
68136   if (arg1) (arg1)->bottom = arg2;
68137 }
68138
68139
68140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68141   float jresult ;
68142   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68143   float result;
68144
68145   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68146   result = (float) ((arg1)->bottom);
68147   jresult = result;
68148   return jresult;
68149 }
68150
68151
68152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68153   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68154
68155   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68156   {
68157     try {
68158       delete arg1;
68159     } catch (std::out_of_range& e) {
68160       {
68161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68162       };
68163     } catch (std::exception& e) {
68164       {
68165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68166       };
68167     } catch (Dali::DaliException e) {
68168       {
68169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68170       };
68171     } catch (...) {
68172       {
68173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68174       };
68175     }
68176   }
68177
68178 }
68179
68180
68181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68182   void * jresult ;
68183   Dali::Toolkit::Alignment *result = 0 ;
68184
68185   {
68186     try {
68187       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68188     } catch (std::out_of_range& e) {
68189       {
68190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (std::exception& e) {
68193       {
68194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68195       };
68196     } catch (Dali::DaliException e) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68199       };
68200     } catch (...) {
68201       {
68202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68203       };
68204     }
68205   }
68206
68207   jresult = (void *)result;
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68213   void * jresult ;
68214   Dali::Toolkit::Alignment::Type arg1 ;
68215   Dali::Toolkit::Alignment::Type arg2 ;
68216   Dali::Toolkit::Alignment result;
68217
68218   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68219   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68220   {
68221     try {
68222       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68223     } catch (std::out_of_range& e) {
68224       {
68225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68226       };
68227     } catch (std::exception& e) {
68228       {
68229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68230       };
68231     } catch (Dali::DaliException e) {
68232       {
68233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68234       };
68235     } catch (...) {
68236       {
68237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68238       };
68239     }
68240   }
68241
68242   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68243   return jresult;
68244 }
68245
68246
68247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68248   void * jresult ;
68249   Dali::Toolkit::Alignment::Type arg1 ;
68250   Dali::Toolkit::Alignment result;
68251
68252   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68253   {
68254     try {
68255       result = Dali::Toolkit::Alignment::New(arg1);
68256     } catch (std::out_of_range& e) {
68257       {
68258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68259       };
68260     } catch (std::exception& e) {
68261       {
68262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68263       };
68264     } catch (Dali::DaliException e) {
68265       {
68266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68267       };
68268     } catch (...) {
68269       {
68270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68271       };
68272     }
68273   }
68274
68275   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68276   return jresult;
68277 }
68278
68279
68280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68281   void * jresult ;
68282   Dali::Toolkit::Alignment result;
68283
68284   {
68285     try {
68286       result = Dali::Toolkit::Alignment::New();
68287     } catch (std::out_of_range& e) {
68288       {
68289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68290       };
68291     } catch (std::exception& e) {
68292       {
68293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68294       };
68295     } catch (Dali::DaliException e) {
68296       {
68297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68298       };
68299     } catch (...) {
68300       {
68301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68302       };
68303     }
68304   }
68305
68306   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68312   void * jresult ;
68313   Dali::Toolkit::Alignment *arg1 = 0 ;
68314   Dali::Toolkit::Alignment *result = 0 ;
68315
68316   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68317   if (!arg1) {
68318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68319     return 0;
68320   }
68321   {
68322     try {
68323       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68324     } catch (std::out_of_range& e) {
68325       {
68326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (std::exception& e) {
68329       {
68330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68331       };
68332     } catch (Dali::DaliException e) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68335       };
68336     } catch (...) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68339       };
68340     }
68341   }
68342
68343   jresult = (void *)result;
68344   return jresult;
68345 }
68346
68347
68348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68349   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68350
68351   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68352   {
68353     try {
68354       delete arg1;
68355     } catch (std::out_of_range& e) {
68356       {
68357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68358       };
68359     } catch (std::exception& e) {
68360       {
68361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68362       };
68363     } catch (Dali::DaliException e) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68366       };
68367     } catch (...) {
68368       {
68369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68370       };
68371     }
68372   }
68373
68374 }
68375
68376
68377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68378   void * jresult ;
68379   Dali::BaseHandle arg1 ;
68380   Dali::BaseHandle *argp1 ;
68381   Dali::Toolkit::Alignment result;
68382
68383   argp1 = (Dali::BaseHandle *)jarg1;
68384   if (!argp1) {
68385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68386     return 0;
68387   }
68388   arg1 = *argp1;
68389   {
68390     try {
68391       result = Dali::Toolkit::Alignment::DownCast(arg1);
68392     } catch (std::out_of_range& e) {
68393       {
68394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68395       };
68396     } catch (std::exception& e) {
68397       {
68398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68399       };
68400     } catch (Dali::DaliException e) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68403       };
68404     } catch (...) {
68405       {
68406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68407       };
68408     }
68409   }
68410
68411   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68412   return jresult;
68413 }
68414
68415
68416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68417   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68418   Dali::Toolkit::Alignment::Type arg2 ;
68419
68420   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68421   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68422   {
68423     try {
68424       (arg1)->SetAlignmentType(arg2);
68425     } catch (std::out_of_range& e) {
68426       {
68427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68428       };
68429     } catch (std::exception& e) {
68430       {
68431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68432       };
68433     } catch (Dali::DaliException e) {
68434       {
68435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68436       };
68437     } catch (...) {
68438       {
68439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68440       };
68441     }
68442   }
68443
68444 }
68445
68446
68447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68448   int jresult ;
68449   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68450   Dali::Toolkit::Alignment::Type result;
68451
68452   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68453   {
68454     try {
68455       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68456     } catch (std::out_of_range& e) {
68457       {
68458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68459       };
68460     } catch (std::exception& e) {
68461       {
68462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68463       };
68464     } catch (Dali::DaliException e) {
68465       {
68466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68467       };
68468     } catch (...) {
68469       {
68470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68471       };
68472     }
68473   }
68474
68475   jresult = (int)result;
68476   return jresult;
68477 }
68478
68479
68480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68481   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68482   Dali::Toolkit::Alignment::Scaling arg2 ;
68483
68484   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68485   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68486   {
68487     try {
68488       (arg1)->SetScaling(arg2);
68489     } catch (std::out_of_range& e) {
68490       {
68491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68492       };
68493     } catch (std::exception& e) {
68494       {
68495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68496       };
68497     } catch (Dali::DaliException e) {
68498       {
68499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68500       };
68501     } catch (...) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68504       };
68505     }
68506   }
68507
68508 }
68509
68510
68511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68512   int jresult ;
68513   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68514   Dali::Toolkit::Alignment::Scaling result;
68515
68516   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68517   {
68518     try {
68519       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68520     } catch (std::out_of_range& e) {
68521       {
68522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68523       };
68524     } catch (std::exception& e) {
68525       {
68526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68527       };
68528     } catch (Dali::DaliException e) {
68529       {
68530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68531       };
68532     } catch (...) {
68533       {
68534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68535       };
68536     }
68537   }
68538
68539   jresult = (int)result;
68540   return jresult;
68541 }
68542
68543
68544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68545   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68546   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68547
68548   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68549   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68550   if (!arg2) {
68551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68552     return ;
68553   }
68554   {
68555     try {
68556       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68557     } catch (std::out_of_range& e) {
68558       {
68559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68560       };
68561     } catch (std::exception& e) {
68562       {
68563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68564       };
68565     } catch (Dali::DaliException e) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68568       };
68569     } catch (...) {
68570       {
68571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68572       };
68573     }
68574   }
68575
68576 }
68577
68578
68579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68580   void * jresult ;
68581   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68582   Dali::Toolkit::Alignment::Padding *result = 0 ;
68583
68584   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68585   {
68586     try {
68587       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68588     } catch (std::out_of_range& e) {
68589       {
68590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68591       };
68592     } catch (std::exception& e) {
68593       {
68594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68595       };
68596     } catch (Dali::DaliException e) {
68597       {
68598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68599       };
68600     } catch (...) {
68601       {
68602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68603       };
68604     }
68605   }
68606
68607   jresult = (void *)result;
68608   return jresult;
68609 }
68610
68611
68612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68613   void * jresult ;
68614   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68615   Dali::Toolkit::Alignment *arg2 = 0 ;
68616   Dali::Toolkit::Alignment *result = 0 ;
68617
68618   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68619   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68620   if (!arg2) {
68621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68622     return 0;
68623   }
68624   {
68625     try {
68626       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68627     } catch (std::out_of_range& e) {
68628       {
68629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68630       };
68631     } catch (std::exception& e) {
68632       {
68633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68634       };
68635     } catch (Dali::DaliException e) {
68636       {
68637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68638       };
68639     } catch (...) {
68640       {
68641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68642       };
68643     }
68644   }
68645
68646   jresult = (void *)result;
68647   return jresult;
68648 }
68649
68650
68651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68652   int jresult ;
68653   int result;
68654
68655   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68656   jresult = (int)result;
68657   return jresult;
68658 }
68659
68660
68661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68662   int jresult ;
68663   int result;
68664
68665   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68666   jresult = (int)result;
68667   return jresult;
68668 }
68669
68670
68671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68672   int jresult ;
68673   int result;
68674
68675   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68676   jresult = (int)result;
68677   return jresult;
68678 }
68679
68680
68681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68682   int jresult ;
68683   int result;
68684
68685   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68686   jresult = (int)result;
68687   return jresult;
68688 }
68689
68690
68691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68692   int jresult ;
68693   int result;
68694
68695   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68696   jresult = (int)result;
68697   return jresult;
68698 }
68699
68700
68701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68702   int jresult ;
68703   int result;
68704
68705   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68706   jresult = (int)result;
68707   return jresult;
68708 }
68709
68710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
68711   int jresult ;
68712   int result;
68713
68714   result = (int)Dali::Toolkit::Button::Property::LABEL;
68715   jresult = (int)result;
68716   return jresult;
68717 }
68718
68719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
68720   void * jresult ;
68721   Dali::Toolkit::Button::Property *result = 0 ;
68722
68723   {
68724     try {
68725       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
68726     } catch (std::out_of_range& e) {
68727       {
68728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68729       };
68730     } catch (std::exception& e) {
68731       {
68732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68733       };
68734     } catch (Dali::DaliException e) {
68735       {
68736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68737       };
68738     } catch (...) {
68739       {
68740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68741       };
68742     }
68743   }
68744
68745   jresult = (void *)result;
68746   return jresult;
68747 }
68748
68749
68750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
68751   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
68752
68753   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
68754   {
68755     try {
68756       delete arg1;
68757     } catch (std::out_of_range& e) {
68758       {
68759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68760       };
68761     } catch (std::exception& e) {
68762       {
68763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68764       };
68765     } catch (Dali::DaliException e) {
68766       {
68767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68768       };
68769     } catch (...) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68772       };
68773     }
68774   }
68775
68776 }
68777
68778
68779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
68780   void * jresult ;
68781   Dali::Toolkit::Button *result = 0 ;
68782
68783   {
68784     try {
68785       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
68786     } catch (std::out_of_range& e) {
68787       {
68788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68789       };
68790     } catch (std::exception& e) {
68791       {
68792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68793       };
68794     } catch (Dali::DaliException e) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68797       };
68798     } catch (...) {
68799       {
68800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68801       };
68802     }
68803   }
68804
68805   jresult = (void *)result;
68806   return jresult;
68807 }
68808
68809
68810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
68811   void * jresult ;
68812   Dali::Toolkit::Button *arg1 = 0 ;
68813   Dali::Toolkit::Button *result = 0 ;
68814
68815   arg1 = (Dali::Toolkit::Button *)jarg1;
68816   if (!arg1) {
68817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
68818     return 0;
68819   }
68820   {
68821     try {
68822       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
68823     } catch (std::out_of_range& e) {
68824       {
68825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68826       };
68827     } catch (std::exception& e) {
68828       {
68829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68830       };
68831     } catch (Dali::DaliException e) {
68832       {
68833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68834       };
68835     } catch (...) {
68836       {
68837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68838       };
68839     }
68840   }
68841
68842   jresult = (void *)result;
68843   return jresult;
68844 }
68845
68846
68847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
68848   void * jresult ;
68849   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
68850   Dali::Toolkit::Button *arg2 = 0 ;
68851   Dali::Toolkit::Button *result = 0 ;
68852
68853   arg1 = (Dali::Toolkit::Button *)jarg1;
68854   arg2 = (Dali::Toolkit::Button *)jarg2;
68855   if (!arg2) {
68856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
68857     return 0;
68858   }
68859   {
68860     try {
68861       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
68862     } catch (std::out_of_range& e) {
68863       {
68864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68865       };
68866     } catch (std::exception& e) {
68867       {
68868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68869       };
68870     } catch (Dali::DaliException e) {
68871       {
68872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68873       };
68874     } catch (...) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68877       };
68878     }
68879   }
68880
68881   jresult = (void *)result;
68882   return jresult;
68883 }
68884
68885
68886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
68887   void * jresult ;
68888   Dali::BaseHandle arg1 ;
68889   Dali::BaseHandle *argp1 ;
68890   Dali::Toolkit::Button result;
68891
68892   argp1 = (Dali::BaseHandle *)jarg1;
68893   if (!argp1) {
68894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68895     return 0;
68896   }
68897   arg1 = *argp1;
68898   {
68899     try {
68900       result = Dali::Toolkit::Button::DownCast(arg1);
68901     } catch (std::out_of_range& e) {
68902       {
68903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68904       };
68905     } catch (std::exception& e) {
68906       {
68907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68908       };
68909     } catch (Dali::DaliException e) {
68910       {
68911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68912       };
68913     } catch (...) {
68914       {
68915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68916       };
68917     }
68918   }
68919
68920   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
68921   return jresult;
68922 }
68923
68924
68925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
68926   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
68927
68928   arg1 = (Dali::Toolkit::Button *)jarg1;
68929   {
68930     try {
68931       delete arg1;
68932     } catch (std::out_of_range& e) {
68933       {
68934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68935       };
68936     } catch (std::exception& e) {
68937       {
68938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68939       };
68940     } catch (Dali::DaliException e) {
68941       {
68942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68943       };
68944     } catch (...) {
68945       {
68946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68947       };
68948     }
68949   }
68950
68951 }
68952
68953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
68954   void * jresult ;
68955   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
68956   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
68957
68958   arg1 = (Dali::Toolkit::Button *)jarg1;
68959   {
68960     try {
68961       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
68962     } catch (std::out_of_range& e) {
68963       {
68964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68965       };
68966     } catch (std::exception& e) {
68967       {
68968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68969       };
68970     } catch (Dali::DaliException e) {
68971       {
68972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68973       };
68974     } catch (...) {
68975       {
68976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68977       };
68978     }
68979   }
68980
68981   jresult = (void *)result;
68982   return jresult;
68983 }
68984
68985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
68986   void * jresult ;
68987   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
68988   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
68989
68990   arg1 = (Dali::Toolkit::Button *)jarg1;
68991   {
68992     try {
68993       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
68994     } catch (std::out_of_range& e) {
68995       {
68996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68997       };
68998     } catch (std::exception& e) {
68999       {
69000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69001       };
69002     } catch (Dali::DaliException e) {
69003       {
69004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69005       };
69006     } catch (...) {
69007       {
69008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69009       };
69010     }
69011   }
69012
69013   jresult = (void *)result;
69014   return jresult;
69015 }
69016
69017
69018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69019   void * jresult ;
69020   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69021   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69022
69023   arg1 = (Dali::Toolkit::Button *)jarg1;
69024   {
69025     try {
69026       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69027     } catch (std::out_of_range& e) {
69028       {
69029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69030       };
69031     } catch (std::exception& e) {
69032       {
69033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (Dali::DaliException e) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69038       };
69039     } catch (...) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69042       };
69043     }
69044   }
69045
69046   jresult = (void *)result;
69047   return jresult;
69048 }
69049
69050
69051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69052   void * jresult ;
69053   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69054   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69055
69056   arg1 = (Dali::Toolkit::Button *)jarg1;
69057   {
69058     try {
69059       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69060     } catch (std::out_of_range& e) {
69061       {
69062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69063       };
69064     } catch (std::exception& e) {
69065       {
69066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69067       };
69068     } catch (Dali::DaliException e) {
69069       {
69070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69071       };
69072     } catch (...) {
69073       {
69074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69075       };
69076     }
69077   }
69078
69079   jresult = (void *)result;
69080   return jresult;
69081 }
69082
69083
69084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69085   void * jresult ;
69086   Dali::Toolkit::CheckBoxButton *result = 0 ;
69087
69088   {
69089     try {
69090       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
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_CheckBoxButton__SWIG_1(void * jarg1) {
69116   void * jresult ;
69117   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69118   Dali::Toolkit::CheckBoxButton *result = 0 ;
69119
69120   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69121   if (!arg1) {
69122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69123     return 0;
69124   }
69125   {
69126     try {
69127       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton 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_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69153   void * jresult ;
69154   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69155   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69156   Dali::Toolkit::CheckBoxButton *result = 0 ;
69157
69158   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69159   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69160   if (!arg2) {
69161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69162     return 0;
69163   }
69164   {
69165     try {
69166       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton 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_delete_CheckBoxButton(void * jarg1) {
69192   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69193
69194   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69195   {
69196     try {
69197       delete arg1;
69198     } catch (std::out_of_range& e) {
69199       {
69200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69201       };
69202     } catch (std::exception& e) {
69203       {
69204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69205       };
69206     } catch (Dali::DaliException e) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69209       };
69210     } catch (...) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69213       };
69214     }
69215   }
69216
69217 }
69218
69219
69220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69221   void * jresult ;
69222   Dali::Toolkit::CheckBoxButton result;
69223
69224   {
69225     try {
69226       result = Dali::Toolkit::CheckBoxButton::New();
69227     } catch (std::out_of_range& e) {
69228       {
69229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69230       };
69231     } catch (std::exception& e) {
69232       {
69233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69234       };
69235     } catch (Dali::DaliException e) {
69236       {
69237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69238       };
69239     } catch (...) {
69240       {
69241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69242       };
69243     }
69244   }
69245
69246   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69247   return jresult;
69248 }
69249
69250
69251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69252   void * jresult ;
69253   Dali::BaseHandle arg1 ;
69254   Dali::BaseHandle *argp1 ;
69255   Dali::Toolkit::CheckBoxButton result;
69256
69257   argp1 = (Dali::BaseHandle *)jarg1;
69258   if (!argp1) {
69259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69260     return 0;
69261   }
69262   arg1 = *argp1;
69263   {
69264     try {
69265       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69266     } catch (std::out_of_range& e) {
69267       {
69268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69269       };
69270     } catch (std::exception& e) {
69271       {
69272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69273       };
69274     } catch (Dali::DaliException e) {
69275       {
69276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69277       };
69278     } catch (...) {
69279       {
69280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69281       };
69282     }
69283   }
69284
69285   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69286   return jresult;
69287 }
69288
69289
69290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69291   int jresult ;
69292   int result;
69293
69294   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69295   jresult = (int)result;
69296   return jresult;
69297 }
69298
69299
69300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69301   int jresult ;
69302   int result;
69303
69304   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69305   jresult = (int)result;
69306   return jresult;
69307 }
69308
69309
69310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69311   int jresult ;
69312   int result;
69313
69314   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69315   jresult = (int)result;
69316   return jresult;
69317 }
69318
69319
69320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69321   int jresult ;
69322   int result;
69323
69324   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69325   jresult = (int)result;
69326   return jresult;
69327 }
69328
69329
69330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69331   int jresult ;
69332   int result;
69333
69334   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69335   jresult = (int)result;
69336   return jresult;
69337 }
69338
69339
69340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69341   void * jresult ;
69342   Dali::Toolkit::PushButton::Property *result = 0 ;
69343
69344   {
69345     try {
69346       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69347     } catch (std::out_of_range& e) {
69348       {
69349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69350       };
69351     } catch (std::exception& e) {
69352       {
69353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (Dali::DaliException e) {
69356       {
69357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69358       };
69359     } catch (...) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69362       };
69363     }
69364   }
69365
69366   jresult = (void *)result;
69367   return jresult;
69368 }
69369
69370
69371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69372   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69373
69374   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69375   {
69376     try {
69377       delete arg1;
69378     } catch (std::out_of_range& e) {
69379       {
69380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69381       };
69382     } catch (std::exception& e) {
69383       {
69384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69385       };
69386     } catch (Dali::DaliException e) {
69387       {
69388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69389       };
69390     } catch (...) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69393       };
69394     }
69395   }
69396
69397 }
69398
69399
69400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69401   void * jresult ;
69402   Dali::Toolkit::PushButton *result = 0 ;
69403
69404   {
69405     try {
69406       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69407     } catch (std::out_of_range& e) {
69408       {
69409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69410       };
69411     } catch (std::exception& e) {
69412       {
69413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69414       };
69415     } catch (Dali::DaliException e) {
69416       {
69417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69418       };
69419     } catch (...) {
69420       {
69421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69422       };
69423     }
69424   }
69425
69426   jresult = (void *)result;
69427   return jresult;
69428 }
69429
69430
69431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69432   void * jresult ;
69433   Dali::Toolkit::PushButton *arg1 = 0 ;
69434   Dali::Toolkit::PushButton *result = 0 ;
69435
69436   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69437   if (!arg1) {
69438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69439     return 0;
69440   }
69441   {
69442     try {
69443       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69444     } catch (std::out_of_range& e) {
69445       {
69446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69447       };
69448     } catch (std::exception& e) {
69449       {
69450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69451       };
69452     } catch (Dali::DaliException e) {
69453       {
69454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69455       };
69456     } catch (...) {
69457       {
69458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69459       };
69460     }
69461   }
69462
69463   jresult = (void *)result;
69464   return jresult;
69465 }
69466
69467
69468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69469   void * jresult ;
69470   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69471   Dali::Toolkit::PushButton *arg2 = 0 ;
69472   Dali::Toolkit::PushButton *result = 0 ;
69473
69474   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69475   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69476   if (!arg2) {
69477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69478     return 0;
69479   }
69480   {
69481     try {
69482       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69483     } catch (std::out_of_range& e) {
69484       {
69485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69486       };
69487     } catch (std::exception& e) {
69488       {
69489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69490       };
69491     } catch (Dali::DaliException e) {
69492       {
69493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69494       };
69495     } catch (...) {
69496       {
69497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69498       };
69499     }
69500   }
69501
69502   jresult = (void *)result;
69503   return jresult;
69504 }
69505
69506
69507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69508   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69509
69510   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69511   {
69512     try {
69513       delete arg1;
69514     } catch (std::out_of_range& e) {
69515       {
69516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69517       };
69518     } catch (std::exception& e) {
69519       {
69520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69521       };
69522     } catch (Dali::DaliException e) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69529       };
69530     }
69531   }
69532
69533 }
69534
69535
69536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69537   void * jresult ;
69538   Dali::Toolkit::PushButton result;
69539
69540   {
69541     try {
69542       result = Dali::Toolkit::PushButton::New();
69543     } catch (std::out_of_range& e) {
69544       {
69545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69546       };
69547     } catch (std::exception& e) {
69548       {
69549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69550       };
69551     } catch (Dali::DaliException e) {
69552       {
69553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69554       };
69555     } catch (...) {
69556       {
69557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69558       };
69559     }
69560   }
69561
69562   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69563   return jresult;
69564 }
69565
69566
69567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69568   void * jresult ;
69569   Dali::BaseHandle arg1 ;
69570   Dali::BaseHandle *argp1 ;
69571   Dali::Toolkit::PushButton result;
69572
69573   argp1 = (Dali::BaseHandle *)jarg1;
69574   if (!argp1) {
69575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69576     return 0;
69577   }
69578   arg1 = *argp1;
69579   {
69580     try {
69581       result = Dali::Toolkit::PushButton::DownCast(arg1);
69582     } catch (std::out_of_range& e) {
69583       {
69584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69585       };
69586     } catch (std::exception& e) {
69587       {
69588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69589       };
69590     } catch (Dali::DaliException e) {
69591       {
69592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69593       };
69594     } catch (...) {
69595       {
69596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69597       };
69598     }
69599   }
69600
69601   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69602   return jresult;
69603 }
69604
69605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69606   void * jresult ;
69607   Dali::Toolkit::RadioButton *result = 0 ;
69608
69609   {
69610     try {
69611       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69612     } catch (std::out_of_range& e) {
69613       {
69614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69615       };
69616     } catch (std::exception& e) {
69617       {
69618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69619       };
69620     } catch (Dali::DaliException e) {
69621       {
69622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69623       };
69624     } catch (...) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69627       };
69628     }
69629   }
69630
69631   jresult = (void *)result;
69632   return jresult;
69633 }
69634
69635
69636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69637   void * jresult ;
69638   Dali::Toolkit::RadioButton *arg1 = 0 ;
69639   Dali::Toolkit::RadioButton *result = 0 ;
69640
69641   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69642   if (!arg1) {
69643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69644     return 0;
69645   }
69646   {
69647     try {
69648       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69649     } catch (std::out_of_range& e) {
69650       {
69651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69652       };
69653     } catch (std::exception& e) {
69654       {
69655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69656       };
69657     } catch (Dali::DaliException e) {
69658       {
69659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69660       };
69661     } catch (...) {
69662       {
69663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69664       };
69665     }
69666   }
69667
69668   jresult = (void *)result;
69669   return jresult;
69670 }
69671
69672
69673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69674   void * jresult ;
69675   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69676   Dali::Toolkit::RadioButton *arg2 = 0 ;
69677   Dali::Toolkit::RadioButton *result = 0 ;
69678
69679   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69680   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69681   if (!arg2) {
69682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69683     return 0;
69684   }
69685   {
69686     try {
69687       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
69688     } catch (std::out_of_range& e) {
69689       {
69690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69691       };
69692     } catch (std::exception& e) {
69693       {
69694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69695       };
69696     } catch (Dali::DaliException e) {
69697       {
69698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69699       };
69700     } catch (...) {
69701       {
69702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69703       };
69704     }
69705   }
69706
69707   jresult = (void *)result;
69708   return jresult;
69709 }
69710
69711
69712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
69713   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69714
69715   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69716   {
69717     try {
69718       delete arg1;
69719     } catch (std::out_of_range& e) {
69720       {
69721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69722       };
69723     } catch (std::exception& e) {
69724       {
69725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69726       };
69727     } catch (Dali::DaliException e) {
69728       {
69729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69730       };
69731     } catch (...) {
69732       {
69733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69734       };
69735     }
69736   }
69737
69738 }
69739
69740
69741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
69742   void * jresult ;
69743   Dali::Toolkit::RadioButton result;
69744
69745   {
69746     try {
69747       result = Dali::Toolkit::RadioButton::New();
69748     } catch (std::out_of_range& e) {
69749       {
69750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69751       };
69752     } catch (std::exception& e) {
69753       {
69754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69755       };
69756     } catch (Dali::DaliException e) {
69757       {
69758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69759       };
69760     } catch (...) {
69761       {
69762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69763       };
69764     }
69765   }
69766
69767   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69768   return jresult;
69769 }
69770
69771
69772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
69773   void * jresult ;
69774   std::string *arg1 = 0 ;
69775   Dali::Toolkit::RadioButton result;
69776
69777   if (!jarg1) {
69778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69779     return 0;
69780   }
69781   std::string arg1_str(jarg1);
69782   arg1 = &arg1_str;
69783   {
69784     try {
69785       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
69786     } catch (std::out_of_range& e) {
69787       {
69788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69789       };
69790     } catch (std::exception& e) {
69791       {
69792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69793       };
69794     } catch (Dali::DaliException e) {
69795       {
69796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69797       };
69798     } catch (...) {
69799       {
69800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69801       };
69802     }
69803   }
69804
69805   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69806
69807   //argout typemap for const std::string&
69808
69809   return jresult;
69810 }
69811
69812
69813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
69814   void * jresult ;
69815   Dali::BaseHandle arg1 ;
69816   Dali::BaseHandle *argp1 ;
69817   Dali::Toolkit::RadioButton result;
69818
69819   argp1 = (Dali::BaseHandle *)jarg1;
69820   if (!argp1) {
69821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69822     return 0;
69823   }
69824   arg1 = *argp1;
69825   {
69826     try {
69827       result = Dali::Toolkit::RadioButton::DownCast(arg1);
69828     } catch (std::out_of_range& e) {
69829       {
69830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69831       };
69832     } catch (std::exception& e) {
69833       {
69834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (Dali::DaliException e) {
69837       {
69838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69839       };
69840     } catch (...) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69843       };
69844     }
69845   }
69846
69847   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69848   return jresult;
69849 }
69850
69851
69852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
69853   int jresult ;
69854   int result;
69855
69856   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
69857   jresult = (int)result;
69858   return jresult;
69859 }
69860
69861
69862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
69863   int jresult ;
69864   int result;
69865
69866   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
69867   jresult = (int)result;
69868   return jresult;
69869 }
69870
69871
69872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
69873   int jresult ;
69874   int result;
69875
69876   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
69877   jresult = (int)result;
69878   return jresult;
69879 }
69880
69881
69882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
69883   int jresult ;
69884   int result;
69885
69886   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
69887   jresult = (int)result;
69888   return jresult;
69889 }
69890
69891
69892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
69893   int jresult ;
69894   int result;
69895
69896   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
69897   jresult = (int)result;
69898   return jresult;
69899 }
69900
69901
69902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
69903   int jresult ;
69904   int result;
69905
69906   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
69907   jresult = (int)result;
69908   return jresult;
69909 }
69910
69911
69912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
69913   void * jresult ;
69914   Dali::Toolkit::FlexContainer::Property *result = 0 ;
69915
69916   {
69917     try {
69918       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
69919     } catch (std::out_of_range& e) {
69920       {
69921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69922       };
69923     } catch (std::exception& e) {
69924       {
69925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69926       };
69927     } catch (Dali::DaliException e) {
69928       {
69929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69930       };
69931     } catch (...) {
69932       {
69933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69934       };
69935     }
69936   }
69937
69938   jresult = (void *)result;
69939   return jresult;
69940 }
69941
69942
69943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
69944   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
69945
69946   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
69947   {
69948     try {
69949       delete arg1;
69950     } catch (std::out_of_range& e) {
69951       {
69952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69953       };
69954     } catch (std::exception& e) {
69955       {
69956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69957       };
69958     } catch (Dali::DaliException e) {
69959       {
69960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69961       };
69962     } catch (...) {
69963       {
69964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69965       };
69966     }
69967   }
69968
69969 }
69970
69971
69972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
69973   int jresult ;
69974   int result;
69975
69976   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
69977   jresult = (int)result;
69978   return jresult;
69979 }
69980
69981
69982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
69983   int jresult ;
69984   int result;
69985
69986   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
69987   jresult = (int)result;
69988   return jresult;
69989 }
69990
69991
69992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
69993   int jresult ;
69994   int result;
69995
69996   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
69997   jresult = (int)result;
69998   return jresult;
69999 }
70000
70001
70002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70003   void * jresult ;
70004   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70005
70006   {
70007     try {
70008       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (Dali::DaliException e) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027
70028   jresult = (void *)result;
70029   return jresult;
70030 }
70031
70032
70033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70034   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70035
70036   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70037   {
70038     try {
70039       delete arg1;
70040     } catch (std::out_of_range& e) {
70041       {
70042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70043       };
70044     } catch (std::exception& e) {
70045       {
70046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70047       };
70048     } catch (Dali::DaliException e) {
70049       {
70050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70051       };
70052     } catch (...) {
70053       {
70054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70055       };
70056     }
70057   }
70058
70059 }
70060
70061
70062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70063   void * jresult ;
70064   Dali::Toolkit::FlexContainer *result = 0 ;
70065
70066   {
70067     try {
70068       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70069     } catch (std::out_of_range& e) {
70070       {
70071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70072       };
70073     } catch (std::exception& e) {
70074       {
70075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70076       };
70077     } catch (Dali::DaliException e) {
70078       {
70079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70080       };
70081     } catch (...) {
70082       {
70083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70084       };
70085     }
70086   }
70087
70088   jresult = (void *)result;
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70094   void * jresult ;
70095   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70096   Dali::Toolkit::FlexContainer *result = 0 ;
70097
70098   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70099   if (!arg1) {
70100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70101     return 0;
70102   }
70103   {
70104     try {
70105       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70106     } catch (std::out_of_range& e) {
70107       {
70108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70109       };
70110     } catch (std::exception& e) {
70111       {
70112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (Dali::DaliException e) {
70115       {
70116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70117       };
70118     } catch (...) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70121       };
70122     }
70123   }
70124
70125   jresult = (void *)result;
70126   return jresult;
70127 }
70128
70129
70130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70131   void * jresult ;
70132   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70133   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70134   Dali::Toolkit::FlexContainer *result = 0 ;
70135
70136   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70137   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70138   if (!arg2) {
70139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70140     return 0;
70141   }
70142   {
70143     try {
70144       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70145     } catch (std::out_of_range& e) {
70146       {
70147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70148       };
70149     } catch (std::exception& e) {
70150       {
70151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70152       };
70153     } catch (Dali::DaliException e) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70156       };
70157     } catch (...) {
70158       {
70159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70160       };
70161     }
70162   }
70163
70164   jresult = (void *)result;
70165   return jresult;
70166 }
70167
70168
70169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70170   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70171
70172   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70173   {
70174     try {
70175       delete arg1;
70176     } catch (std::out_of_range& e) {
70177       {
70178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70179       };
70180     } catch (std::exception& e) {
70181       {
70182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70183       };
70184     } catch (Dali::DaliException e) {
70185       {
70186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70187       };
70188     } catch (...) {
70189       {
70190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70191       };
70192     }
70193   }
70194
70195 }
70196
70197
70198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70199   void * jresult ;
70200   Dali::Toolkit::FlexContainer result;
70201
70202   {
70203     try {
70204       result = Dali::Toolkit::FlexContainer::New();
70205     } catch (std::out_of_range& e) {
70206       {
70207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70208       };
70209     } catch (std::exception& e) {
70210       {
70211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70212       };
70213     } catch (Dali::DaliException e) {
70214       {
70215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70216       };
70217     } catch (...) {
70218       {
70219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70220       };
70221     }
70222   }
70223
70224   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70225   return jresult;
70226 }
70227
70228
70229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70230   void * jresult ;
70231   Dali::BaseHandle arg1 ;
70232   Dali::BaseHandle *argp1 ;
70233   Dali::Toolkit::FlexContainer result;
70234
70235   argp1 = (Dali::BaseHandle *)jarg1;
70236   if (!argp1) {
70237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70238     return 0;
70239   }
70240   arg1 = *argp1;
70241   {
70242     try {
70243       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70244     } catch (std::out_of_range& e) {
70245       {
70246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70247       };
70248     } catch (std::exception& e) {
70249       {
70250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70251       };
70252     } catch (Dali::DaliException e) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70255       };
70256     } catch (...) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70259       };
70260     }
70261   }
70262
70263   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70264   return jresult;
70265 }
70266
70267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70268   int jresult ;
70269   int result;
70270
70271   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70272   jresult = (int)result;
70273   return jresult;
70274 }
70275
70276
70277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70278   int jresult ;
70279   int result;
70280
70281   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70282   jresult = (int)result;
70283   return jresult;
70284 }
70285
70286
70287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70288   int jresult ;
70289   int result;
70290
70291   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70292   jresult = (int)result;
70293   return jresult;
70294 }
70295
70296
70297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70298   void * jresult ;
70299   Dali::Toolkit::ImageView::Property *result = 0 ;
70300
70301   {
70302     try {
70303       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70304     } catch (std::out_of_range& e) {
70305       {
70306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70307       };
70308     } catch (std::exception& e) {
70309       {
70310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (Dali::DaliException e) {
70313       {
70314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70315       };
70316     } catch (...) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70319       };
70320     }
70321   }
70322
70323   jresult = (void *)result;
70324   return jresult;
70325 }
70326
70327
70328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70329   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70330
70331   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70332   {
70333     try {
70334       delete arg1;
70335     } catch (std::out_of_range& e) {
70336       {
70337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70338       };
70339     } catch (std::exception& e) {
70340       {
70341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70342       };
70343     } catch (Dali::DaliException e) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70346       };
70347     } catch (...) {
70348       {
70349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70350       };
70351     }
70352   }
70353
70354 }
70355
70356
70357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70358   void * jresult ;
70359   Dali::Toolkit::ImageView *result = 0 ;
70360
70361   {
70362     try {
70363       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70364     } catch (std::out_of_range& e) {
70365       {
70366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (std::exception& e) {
70369       {
70370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (Dali::DaliException e) {
70373       {
70374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70375       };
70376     } catch (...) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70379       };
70380     }
70381   }
70382
70383   jresult = (void *)result;
70384   return jresult;
70385 }
70386
70387
70388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70389   void * jresult ;
70390   Dali::Toolkit::ImageView result;
70391
70392   {
70393     try {
70394       result = Dali::Toolkit::ImageView::New();
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70402       };
70403     } catch (Dali::DaliException e) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70410       };
70411     }
70412   }
70413
70414   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70415   return jresult;
70416 }
70417
70418
70419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70420   void * jresult ;
70421   Dali::Image arg1 ;
70422   Dali::Image *argp1 ;
70423   Dali::Toolkit::ImageView result;
70424
70425   argp1 = (Dali::Image *)jarg1;
70426   if (!argp1) {
70427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70428     return 0;
70429   }
70430   arg1 = *argp1;
70431   {
70432     try {
70433       result = Dali::Toolkit::ImageView::New(arg1);
70434     } catch (std::out_of_range& e) {
70435       {
70436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70437       };
70438     } catch (std::exception& e) {
70439       {
70440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70441       };
70442     } catch (Dali::DaliException e) {
70443       {
70444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70445       };
70446     } catch (...) {
70447       {
70448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70449       };
70450     }
70451   }
70452
70453   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70454   return jresult;
70455 }
70456
70457
70458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70459   void * jresult ;
70460   std::string *arg1 = 0 ;
70461   Dali::Toolkit::ImageView result;
70462
70463   if (!jarg1) {
70464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70465     return 0;
70466   }
70467   std::string arg1_str(jarg1);
70468   arg1 = &arg1_str;
70469   {
70470     try {
70471       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70472     } catch (std::out_of_range& e) {
70473       {
70474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70475       };
70476     } catch (std::exception& e) {
70477       {
70478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70479       };
70480     } catch (Dali::DaliException e) {
70481       {
70482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70483       };
70484     } catch (...) {
70485       {
70486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70487       };
70488     }
70489   }
70490
70491   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70492
70493   //argout typemap for const std::string&
70494
70495   return jresult;
70496 }
70497
70498
70499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70500   void * jresult ;
70501   std::string *arg1 = 0 ;
70502   Dali::ImageDimensions arg2 ;
70503   Dali::ImageDimensions *argp2 ;
70504   Dali::Toolkit::ImageView result;
70505
70506   if (!jarg1) {
70507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70508     return 0;
70509   }
70510   std::string arg1_str(jarg1);
70511   arg1 = &arg1_str;
70512   argp2 = (Dali::ImageDimensions *)jarg2;
70513   if (!argp2) {
70514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70515     return 0;
70516   }
70517   arg2 = *argp2;
70518   {
70519     try {
70520       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70521     } catch (std::out_of_range& e) {
70522       {
70523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (std::exception& e) {
70526       {
70527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70528       };
70529     } catch (Dali::DaliException e) {
70530       {
70531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70532       };
70533     } catch (...) {
70534       {
70535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70536       };
70537     }
70538   }
70539
70540   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70541
70542   //argout typemap for const std::string&
70543
70544   return jresult;
70545 }
70546
70547
70548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70549   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70550
70551   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70552   {
70553     try {
70554       delete arg1;
70555     } catch (std::out_of_range& e) {
70556       {
70557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70558       };
70559     } catch (std::exception& e) {
70560       {
70561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70562       };
70563     } catch (Dali::DaliException e) {
70564       {
70565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70566       };
70567     } catch (...) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70570       };
70571     }
70572   }
70573
70574 }
70575
70576
70577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70578   void * jresult ;
70579   Dali::Toolkit::ImageView *arg1 = 0 ;
70580   Dali::Toolkit::ImageView *result = 0 ;
70581
70582   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70583   if (!arg1) {
70584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70585     return 0;
70586   }
70587   {
70588     try {
70589       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70605       };
70606     }
70607   }
70608
70609   jresult = (void *)result;
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70615   void * jresult ;
70616   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70617   Dali::Toolkit::ImageView *arg2 = 0 ;
70618   Dali::Toolkit::ImageView *result = 0 ;
70619
70620   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70621   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70622   if (!arg2) {
70623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70624     return 0;
70625   }
70626   {
70627     try {
70628       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70629     } catch (std::out_of_range& e) {
70630       {
70631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70632       };
70633     } catch (std::exception& e) {
70634       {
70635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70636       };
70637     } catch (Dali::DaliException e) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70640       };
70641     } catch (...) {
70642       {
70643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70644       };
70645     }
70646   }
70647
70648   jresult = (void *)result;
70649   return jresult;
70650 }
70651
70652
70653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70654   void * jresult ;
70655   Dali::BaseHandle arg1 ;
70656   Dali::BaseHandle *argp1 ;
70657   Dali::Toolkit::ImageView result;
70658
70659   argp1 = (Dali::BaseHandle *)jarg1;
70660   if (!argp1) {
70661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70662     return 0;
70663   }
70664   arg1 = *argp1;
70665   {
70666     try {
70667       result = Dali::Toolkit::ImageView::DownCast(arg1);
70668     } catch (std::out_of_range& e) {
70669       {
70670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70671       };
70672     } catch (std::exception& e) {
70673       {
70674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70675       };
70676     } catch (Dali::DaliException e) {
70677       {
70678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70679       };
70680     } catch (...) {
70681       {
70682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70683       };
70684     }
70685   }
70686
70687   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70688   return jresult;
70689 }
70690
70691
70692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70693   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70694   Dali::Image arg2 ;
70695   Dali::Image *argp2 ;
70696
70697   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70698   argp2 = (Dali::Image *)jarg2;
70699   if (!argp2) {
70700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70701     return ;
70702   }
70703   arg2 = *argp2;
70704   {
70705     try {
70706       (arg1)->SetImage(arg2);
70707     } catch (std::out_of_range& e) {
70708       {
70709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70710       };
70711     } catch (std::exception& e) {
70712       {
70713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70714       };
70715     } catch (Dali::DaliException e) {
70716       {
70717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70718       };
70719     } catch (...) {
70720       {
70721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70722       };
70723     }
70724   }
70725
70726 }
70727
70728
70729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
70730   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70731   std::string *arg2 = 0 ;
70732
70733   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70734   if (!jarg2) {
70735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70736     return ;
70737   }
70738   std::string arg2_str(jarg2);
70739   arg2 = &arg2_str;
70740   {
70741     try {
70742       (arg1)->SetImage((std::string const &)*arg2);
70743     } catch (std::out_of_range& e) {
70744       {
70745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70746       };
70747     } catch (std::exception& e) {
70748       {
70749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70750       };
70751     } catch (Dali::DaliException e) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70754       };
70755     } catch (...) {
70756       {
70757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70758       };
70759     }
70760   }
70761
70762
70763   //argout typemap for const std::string&
70764
70765 }
70766
70767
70768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
70769   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70770   std::string *arg2 = 0 ;
70771   Dali::ImageDimensions arg3 ;
70772   Dali::ImageDimensions *argp3 ;
70773
70774   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70775   if (!jarg2) {
70776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70777     return ;
70778   }
70779   std::string arg2_str(jarg2);
70780   arg2 = &arg2_str;
70781   argp3 = (Dali::ImageDimensions *)jarg3;
70782   if (!argp3) {
70783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70784     return ;
70785   }
70786   arg3 = *argp3;
70787   {
70788     try {
70789       (arg1)->SetImage((std::string const &)*arg2,arg3);
70790     } catch (std::out_of_range& e) {
70791       {
70792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70793       };
70794     } catch (std::exception& e) {
70795       {
70796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70797       };
70798     } catch (Dali::DaliException e) {
70799       {
70800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70801       };
70802     } catch (...) {
70803       {
70804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70805       };
70806     }
70807   }
70808
70809
70810   //argout typemap for const std::string&
70811
70812 }
70813
70814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
70815   void * jresult ;
70816   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70817   Dali::Image result;
70818
70819   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70820   {
70821     try {
70822       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (Dali::DaliException e) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70834       };
70835     } catch (...) {
70836       {
70837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70838       };
70839     }
70840   }
70841
70842   jresult = new Dali::Image((const Dali::Image &)result);
70843   return jresult;
70844 }
70845
70846
70847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
70848   int jresult ;
70849   int result;
70850
70851   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
70852   jresult = (int)result;
70853   return jresult;
70854 }
70855
70856
70857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
70858   int jresult ;
70859   int result;
70860
70861   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
70862   jresult = (int)result;
70863   return jresult;
70864 }
70865
70866
70867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
70868   int jresult ;
70869   int result;
70870
70871   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
70872   jresult = (int)result;
70873   return jresult;
70874 }
70875
70876
70877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
70878   int jresult ;
70879   int result;
70880
70881   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
70882   jresult = (int)result;
70883   return jresult;
70884 }
70885
70886
70887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
70888   int jresult ;
70889   int result;
70890
70891   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
70892   jresult = (int)result;
70893   return jresult;
70894 }
70895
70896
70897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
70898   int jresult ;
70899   int result;
70900
70901   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
70902   jresult = (int)result;
70903   return jresult;
70904 }
70905
70906
70907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
70908   int jresult ;
70909   int result;
70910
70911   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
70912   jresult = (int)result;
70913   return jresult;
70914 }
70915
70916
70917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
70918   int jresult ;
70919   int result;
70920
70921   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
70922   jresult = (int)result;
70923   return jresult;
70924 }
70925
70926
70927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
70928   void * jresult ;
70929   Dali::Toolkit::Model3dView::Property *result = 0 ;
70930
70931   {
70932     try {
70933       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
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_delete_Model3dView_Property(void * jarg1) {
70959   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
70960
70961   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
70962   {
70963     try {
70964       delete arg1;
70965     } catch (std::out_of_range& e) {
70966       {
70967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70968       };
70969     } catch (std::exception& e) {
70970       {
70971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70972       };
70973     } catch (Dali::DaliException e) {
70974       {
70975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70976       };
70977     } catch (...) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70980       };
70981     }
70982   }
70983
70984 }
70985
70986
70987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
70988   void * jresult ;
70989   Dali::Toolkit::Model3dView result;
70990
70991   {
70992     try {
70993       result = Dali::Toolkit::Model3dView::New();
70994     } catch (std::out_of_range& e) {
70995       {
70996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70997       };
70998     } catch (std::exception& e) {
70999       {
71000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71001       };
71002     } catch (Dali::DaliException e) {
71003       {
71004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71005       };
71006     } catch (...) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71009       };
71010     }
71011   }
71012
71013   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71014   return jresult;
71015 }
71016
71017
71018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71019   void * jresult ;
71020   std::string *arg1 = 0 ;
71021   std::string *arg2 = 0 ;
71022   std::string *arg3 = 0 ;
71023   Dali::Toolkit::Model3dView result;
71024
71025   if (!jarg1) {
71026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71027     return 0;
71028   }
71029   std::string arg1_str(jarg1);
71030   arg1 = &arg1_str;
71031   if (!jarg2) {
71032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71033     return 0;
71034   }
71035   std::string arg2_str(jarg2);
71036   arg2 = &arg2_str;
71037   if (!jarg3) {
71038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71039     return 0;
71040   }
71041   std::string arg3_str(jarg3);
71042   arg3 = &arg3_str;
71043   {
71044     try {
71045       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71046     } catch (std::out_of_range& e) {
71047       {
71048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71049       };
71050     } catch (std::exception& e) {
71051       {
71052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71053       };
71054     } catch (Dali::DaliException e) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71057       };
71058     } catch (...) {
71059       {
71060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71061       };
71062     }
71063   }
71064
71065   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71066
71067   //argout typemap for const std::string&
71068
71069
71070   //argout typemap for const std::string&
71071
71072
71073   //argout typemap for const std::string&
71074
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71080   void * jresult ;
71081   Dali::Toolkit::Model3dView *result = 0 ;
71082
71083   {
71084     try {
71085       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71086     } catch (std::out_of_range& e) {
71087       {
71088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71089       };
71090     } catch (std::exception& e) {
71091       {
71092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71093       };
71094     } catch (Dali::DaliException e) {
71095       {
71096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71097       };
71098     } catch (...) {
71099       {
71100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71101       };
71102     }
71103   }
71104
71105   jresult = (void *)result;
71106   return jresult;
71107 }
71108
71109
71110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71111   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71112
71113   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71114   {
71115     try {
71116       delete arg1;
71117     } catch (std::out_of_range& e) {
71118       {
71119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71120       };
71121     } catch (std::exception& e) {
71122       {
71123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71124       };
71125     } catch (Dali::DaliException e) {
71126       {
71127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71128       };
71129     } catch (...) {
71130       {
71131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71132       };
71133     }
71134   }
71135
71136 }
71137
71138
71139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71140   void * jresult ;
71141   Dali::Toolkit::Model3dView *arg1 = 0 ;
71142   Dali::Toolkit::Model3dView *result = 0 ;
71143
71144   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71145   if (!arg1) {
71146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71147     return 0;
71148   }
71149   {
71150     try {
71151       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71152     } catch (std::out_of_range& e) {
71153       {
71154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71155       };
71156     } catch (std::exception& e) {
71157       {
71158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71159       };
71160     } catch (Dali::DaliException e) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71163       };
71164     } catch (...) {
71165       {
71166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71167       };
71168     }
71169   }
71170
71171   jresult = (void *)result;
71172   return jresult;
71173 }
71174
71175
71176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71177   void * jresult ;
71178   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71179   Dali::Toolkit::Model3dView *arg2 = 0 ;
71180   Dali::Toolkit::Model3dView *result = 0 ;
71181
71182   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71183   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71184   if (!arg2) {
71185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71186     return 0;
71187   }
71188   {
71189     try {
71190       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71191     } catch (std::out_of_range& e) {
71192       {
71193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71194       };
71195     } catch (std::exception& e) {
71196       {
71197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71198       };
71199     } catch (Dali::DaliException e) {
71200       {
71201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71202       };
71203     } catch (...) {
71204       {
71205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71206       };
71207     }
71208   }
71209
71210   jresult = (void *)result;
71211   return jresult;
71212 }
71213
71214
71215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71216   void * jresult ;
71217   Dali::BaseHandle arg1 ;
71218   Dali::BaseHandle *argp1 ;
71219   Dali::Toolkit::Model3dView result;
71220
71221   argp1 = (Dali::BaseHandle *)jarg1;
71222   if (!argp1) {
71223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71224     return 0;
71225   }
71226   arg1 = *argp1;
71227   {
71228     try {
71229       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71230     } catch (std::out_of_range& e) {
71231       {
71232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71233       };
71234     } catch (std::exception& e) {
71235       {
71236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (Dali::DaliException e) {
71239       {
71240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71241       };
71242     } catch (...) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71245       };
71246     }
71247   }
71248
71249   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71250   return jresult;
71251 }
71252
71253
71254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71255   int jresult ;
71256   int result;
71257
71258   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71259   jresult = (int)result;
71260   return jresult;
71261 }
71262
71263
71264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71265   int jresult ;
71266   int result;
71267
71268   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71269   jresult = (int)result;
71270   return jresult;
71271 }
71272
71273
71274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71275   int jresult ;
71276   int result;
71277
71278   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71279   jresult = (int)result;
71280   return jresult;
71281 }
71282
71283
71284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71285   int jresult ;
71286   int result;
71287
71288   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71289   jresult = (int)result;
71290   return jresult;
71291 }
71292
71293
71294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71295   int jresult ;
71296   int result;
71297
71298   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71299   jresult = (int)result;
71300   return jresult;
71301 }
71302
71303
71304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71305   int jresult ;
71306   int result;
71307
71308   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71309   jresult = (int)result;
71310   return jresult;
71311 }
71312
71313
71314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71315   int jresult ;
71316   int result;
71317
71318   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71319   jresult = (int)result;
71320   return jresult;
71321 }
71322
71323
71324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71325   int jresult ;
71326   int result;
71327
71328   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71329   jresult = (int)result;
71330   return jresult;
71331 }
71332
71333
71334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71335   int jresult ;
71336   int result;
71337
71338   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71339   jresult = (int)result;
71340   return jresult;
71341 }
71342
71343
71344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71345   void * jresult ;
71346   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71347
71348   {
71349     try {
71350       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
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 = (void *)result;
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71376   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71377
71378   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71379   {
71380     try {
71381       delete arg1;
71382     } catch (std::out_of_range& e) {
71383       {
71384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71385       };
71386     } catch (std::exception& e) {
71387       {
71388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71389       };
71390     } catch (Dali::DaliException e) {
71391       {
71392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71393       };
71394     } catch (...) {
71395       {
71396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71397       };
71398     }
71399   }
71400
71401 }
71402
71403
71404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71405   void * jresult ;
71406   Dali::Toolkit::ScrollBar *result = 0 ;
71407
71408   {
71409     try {
71410       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71411     } catch (std::out_of_range& e) {
71412       {
71413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71414       };
71415     } catch (std::exception& e) {
71416       {
71417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71418       };
71419     } catch (Dali::DaliException e) {
71420       {
71421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71422       };
71423     } catch (...) {
71424       {
71425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71426       };
71427     }
71428   }
71429
71430   jresult = (void *)result;
71431   return jresult;
71432 }
71433
71434
71435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71436   void * jresult ;
71437   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71438   Dali::Toolkit::ScrollBar *result = 0 ;
71439
71440   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71441   if (!arg1) {
71442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71443     return 0;
71444   }
71445   {
71446     try {
71447       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71448     } catch (std::out_of_range& e) {
71449       {
71450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71451       };
71452     } catch (std::exception& e) {
71453       {
71454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71455       };
71456     } catch (Dali::DaliException e) {
71457       {
71458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71459       };
71460     } catch (...) {
71461       {
71462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71463       };
71464     }
71465   }
71466
71467   jresult = (void *)result;
71468   return jresult;
71469 }
71470
71471
71472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71473   void * jresult ;
71474   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71475   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71476   Dali::Toolkit::ScrollBar *result = 0 ;
71477
71478   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71479   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71480   if (!arg2) {
71481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71482     return 0;
71483   }
71484   {
71485     try {
71486       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71487     } catch (std::out_of_range& e) {
71488       {
71489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71490       };
71491     } catch (std::exception& e) {
71492       {
71493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (Dali::DaliException e) {
71496       {
71497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71498       };
71499     } catch (...) {
71500       {
71501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71502       };
71503     }
71504   }
71505
71506   jresult = (void *)result;
71507   return jresult;
71508 }
71509
71510
71511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71512   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71513
71514   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71515   {
71516     try {
71517       delete arg1;
71518     } catch (std::out_of_range& e) {
71519       {
71520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71521       };
71522     } catch (std::exception& e) {
71523       {
71524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71525       };
71526     } catch (Dali::DaliException e) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71529       };
71530     } catch (...) {
71531       {
71532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71533       };
71534     }
71535   }
71536
71537 }
71538
71539
71540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71541   void * jresult ;
71542   Dali::Toolkit::ScrollBar::Direction arg1 ;
71543   Dali::Toolkit::ScrollBar result;
71544
71545   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71546   {
71547     try {
71548       result = Dali::Toolkit::ScrollBar::New(arg1);
71549     } catch (std::out_of_range& e) {
71550       {
71551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71552       };
71553     } catch (std::exception& e) {
71554       {
71555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71556       };
71557     } catch (Dali::DaliException e) {
71558       {
71559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71560       };
71561     } catch (...) {
71562       {
71563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71564       };
71565     }
71566   }
71567
71568   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71569   return jresult;
71570 }
71571
71572
71573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71574   void * jresult ;
71575   Dali::Toolkit::ScrollBar result;
71576
71577   {
71578     try {
71579       result = Dali::Toolkit::ScrollBar::New();
71580     } catch (std::out_of_range& e) {
71581       {
71582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71583       };
71584     } catch (std::exception& e) {
71585       {
71586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71587       };
71588     } catch (Dali::DaliException e) {
71589       {
71590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71591       };
71592     } catch (...) {
71593       {
71594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71595       };
71596     }
71597   }
71598
71599   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71600   return jresult;
71601 }
71602
71603
71604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71605   void * jresult ;
71606   Dali::BaseHandle arg1 ;
71607   Dali::BaseHandle *argp1 ;
71608   Dali::Toolkit::ScrollBar result;
71609
71610   argp1 = (Dali::BaseHandle *)jarg1;
71611   if (!argp1) {
71612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71613     return 0;
71614   }
71615   arg1 = *argp1;
71616   {
71617     try {
71618       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71619     } catch (std::out_of_range& e) {
71620       {
71621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71622       };
71623     } catch (std::exception& e) {
71624       {
71625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71626       };
71627     } catch (Dali::DaliException e) {
71628       {
71629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71630       };
71631     } catch (...) {
71632       {
71633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71634       };
71635     }
71636   }
71637
71638   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71639   return jresult;
71640 }
71641
71642
71643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71644   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71645   Dali::Handle arg2 ;
71646   Dali::Property::Index arg3 ;
71647   Dali::Property::Index arg4 ;
71648   Dali::Property::Index arg5 ;
71649   Dali::Property::Index arg6 ;
71650   Dali::Handle *argp2 ;
71651
71652   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71653   argp2 = (Dali::Handle *)jarg2;
71654   if (!argp2) {
71655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71656     return ;
71657   }
71658   arg2 = *argp2;
71659   arg3 = (Dali::Property::Index)jarg3;
71660   arg4 = (Dali::Property::Index)jarg4;
71661   arg5 = (Dali::Property::Index)jarg5;
71662   arg6 = (Dali::Property::Index)jarg6;
71663   {
71664     try {
71665       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71666     } catch (std::out_of_range& e) {
71667       {
71668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71669       };
71670     } catch (std::exception& e) {
71671       {
71672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71673       };
71674     } catch (Dali::DaliException e) {
71675       {
71676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71677       };
71678     } catch (...) {
71679       {
71680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71681       };
71682     }
71683   }
71684
71685 }
71686
71687
71688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71689   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71690   Dali::Actor arg2 ;
71691   Dali::Actor *argp2 ;
71692
71693   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71694   argp2 = (Dali::Actor *)jarg2;
71695   if (!argp2) {
71696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71697     return ;
71698   }
71699   arg2 = *argp2;
71700   {
71701     try {
71702       (arg1)->SetScrollIndicator(arg2);
71703     } catch (std::out_of_range& e) {
71704       {
71705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71706       };
71707     } catch (std::exception& e) {
71708       {
71709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71710       };
71711     } catch (Dali::DaliException e) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71714       };
71715     } catch (...) {
71716       {
71717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71718       };
71719     }
71720   }
71721
71722 }
71723
71724
71725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
71726   void * jresult ;
71727   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71728   Dali::Actor result;
71729
71730   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71731   {
71732     try {
71733       result = (arg1)->GetScrollIndicator();
71734     } catch (std::out_of_range& e) {
71735       {
71736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71737       };
71738     } catch (std::exception& e) {
71739       {
71740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71741       };
71742     } catch (Dali::DaliException e) {
71743       {
71744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71745       };
71746     } catch (...) {
71747       {
71748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71749       };
71750     }
71751   }
71752
71753   jresult = new Dali::Actor((const Dali::Actor &)result);
71754   return jresult;
71755 }
71756
71757
71758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
71759   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71760   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
71761
71762   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71763   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
71764   if (!arg2) {
71765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
71766     return ;
71767   }
71768   {
71769     try {
71770       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
71771     } catch (std::out_of_range& e) {
71772       {
71773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71774       };
71775     } catch (std::exception& e) {
71776       {
71777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71778       };
71779     } catch (Dali::DaliException e) {
71780       {
71781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71782       };
71783     } catch (...) {
71784       {
71785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71786       };
71787     }
71788   }
71789
71790 }
71791
71792
71793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
71794   void * jresult ;
71795   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71796
71797   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71798   {
71799     try {
71800       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()));
71801     } catch (std::out_of_range& e) {
71802       {
71803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71804       };
71805     } catch (std::exception& e) {
71806       {
71807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71808       };
71809     } catch (...) {
71810       {
71811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71812       };
71813     }
71814   }
71815   return jresult;
71816 }
71817
71818
71819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
71820   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71821   Dali::Toolkit::ScrollBar::Direction arg2 ;
71822
71823   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71824   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
71825   {
71826     try {
71827       (arg1)->SetScrollDirection(arg2);
71828     } catch (std::out_of_range& e) {
71829       {
71830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71831       };
71832     } catch (std::exception& e) {
71833       {
71834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71835       };
71836     } catch (Dali::DaliException e) {
71837       {
71838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71839       };
71840     } catch (...) {
71841       {
71842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71843       };
71844     }
71845   }
71846
71847 }
71848
71849
71850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
71851   int jresult ;
71852   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71853   Dali::Toolkit::ScrollBar::Direction result;
71854
71855   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71856   {
71857     try {
71858       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
71859     } catch (std::out_of_range& e) {
71860       {
71861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71862       };
71863     } catch (std::exception& e) {
71864       {
71865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71866       };
71867     } catch (Dali::DaliException e) {
71868       {
71869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71870       };
71871     } catch (...) {
71872       {
71873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71874       };
71875     }
71876   }
71877
71878   jresult = (int)result;
71879   return jresult;
71880 }
71881
71882
71883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
71884   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71885   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
71886
71887   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71888   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
71889   {
71890     try {
71891       (arg1)->SetIndicatorHeightPolicy(arg2);
71892     } catch (std::out_of_range& e) {
71893       {
71894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71895       };
71896     } catch (std::exception& e) {
71897       {
71898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71899       };
71900     } catch (Dali::DaliException e) {
71901       {
71902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71903       };
71904     } catch (...) {
71905       {
71906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71907       };
71908     }
71909   }
71910
71911 }
71912
71913
71914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
71915   int jresult ;
71916   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71917   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
71918
71919   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71920   {
71921     try {
71922       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
71923     } catch (std::out_of_range& e) {
71924       {
71925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (std::exception& e) {
71928       {
71929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71930       };
71931     } catch (Dali::DaliException e) {
71932       {
71933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71934       };
71935     } catch (...) {
71936       {
71937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71938       };
71939     }
71940   }
71941
71942   jresult = (int)result;
71943   return jresult;
71944 }
71945
71946
71947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
71948   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71949   float arg2 ;
71950
71951   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71952   arg2 = (float)jarg2;
71953   {
71954     try {
71955       (arg1)->SetIndicatorFixedHeight(arg2);
71956     } catch (std::out_of_range& e) {
71957       {
71958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71959       };
71960     } catch (std::exception& e) {
71961       {
71962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71963       };
71964     } catch (Dali::DaliException e) {
71965       {
71966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71967       };
71968     } catch (...) {
71969       {
71970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71971       };
71972     }
71973   }
71974
71975 }
71976
71977
71978 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
71979   float jresult ;
71980   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71981   float result;
71982
71983   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71984   {
71985     try {
71986       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
71987     } catch (std::out_of_range& e) {
71988       {
71989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71990       };
71991     } catch (std::exception& e) {
71992       {
71993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71994       };
71995     } catch (Dali::DaliException e) {
71996       {
71997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71998       };
71999     } catch (...) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72002       };
72003     }
72004   }
72005
72006   jresult = result;
72007   return jresult;
72008 }
72009
72010
72011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72012   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72013   float arg2 ;
72014
72015   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72016   arg2 = (float)jarg2;
72017   {
72018     try {
72019       (arg1)->SetIndicatorShowDuration(arg2);
72020     } catch (std::out_of_range& e) {
72021       {
72022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72023       };
72024     } catch (std::exception& e) {
72025       {
72026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72027       };
72028     } catch (Dali::DaliException e) {
72029       {
72030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72031       };
72032     } catch (...) {
72033       {
72034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72035       };
72036     }
72037   }
72038
72039 }
72040
72041
72042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72043   float jresult ;
72044   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72045   float result;
72046
72047   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72048   {
72049     try {
72050       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72051     } catch (std::out_of_range& e) {
72052       {
72053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72054       };
72055     } catch (std::exception& e) {
72056       {
72057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72058       };
72059     } catch (Dali::DaliException e) {
72060       {
72061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72062       };
72063     } catch (...) {
72064       {
72065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72066       };
72067     }
72068   }
72069
72070   jresult = result;
72071   return jresult;
72072 }
72073
72074
72075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72076   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72077   float arg2 ;
72078
72079   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72080   arg2 = (float)jarg2;
72081   {
72082     try {
72083       (arg1)->SetIndicatorHideDuration(arg2);
72084     } catch (std::out_of_range& e) {
72085       {
72086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72087       };
72088     } catch (std::exception& e) {
72089       {
72090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72091       };
72092     } catch (Dali::DaliException e) {
72093       {
72094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72095       };
72096     } catch (...) {
72097       {
72098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72099       };
72100     }
72101   }
72102
72103 }
72104
72105
72106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72107   float jresult ;
72108   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72109   float result;
72110
72111   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72112   {
72113     try {
72114       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72115     } catch (std::out_of_range& e) {
72116       {
72117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72118       };
72119     } catch (std::exception& e) {
72120       {
72121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72122       };
72123     } catch (Dali::DaliException e) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72126       };
72127     } catch (...) {
72128       {
72129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72130       };
72131     }
72132   }
72133
72134   jresult = result;
72135   return jresult;
72136 }
72137
72138
72139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72140   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72141
72142   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72143   {
72144     try {
72145       (arg1)->ShowIndicator();
72146     } catch (std::out_of_range& e) {
72147       {
72148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72149       };
72150     } catch (std::exception& e) {
72151       {
72152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72153       };
72154     } catch (Dali::DaliException e) {
72155       {
72156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72157       };
72158     } catch (...) {
72159       {
72160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72161       };
72162     }
72163   }
72164
72165 }
72166
72167
72168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72169   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72170
72171   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72172   {
72173     try {
72174       (arg1)->HideIndicator();
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (Dali::DaliException e) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72186       };
72187     } catch (...) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72190       };
72191     }
72192   }
72193
72194 }
72195
72196
72197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72198   void * jresult ;
72199   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72200   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72201
72202   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72203   {
72204     try {
72205       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72206     } catch (std::out_of_range& e) {
72207       {
72208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72209       };
72210     } catch (std::exception& e) {
72211       {
72212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72213       };
72214     } catch (Dali::DaliException e) {
72215       {
72216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72217       };
72218     } catch (...) {
72219       {
72220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72221       };
72222     }
72223   }
72224
72225   jresult = (void *)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72231   void * jresult ;
72232   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72233   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72234
72235   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72236   {
72237     try {
72238       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72239     } catch (std::out_of_range& e) {
72240       {
72241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72242       };
72243     } catch (std::exception& e) {
72244       {
72245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72246       };
72247     } catch (Dali::DaliException e) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72250       };
72251     } catch (...) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72254       };
72255     }
72256   }
72257
72258   jresult = (void *)result;
72259   return jresult;
72260 }
72261
72262
72263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72264   int jresult ;
72265   int result;
72266
72267   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72268   jresult = (int)result;
72269   return jresult;
72270 }
72271
72272
72273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72274   int jresult ;
72275   int result;
72276
72277   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72278   jresult = (int)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72284   int jresult ;
72285   int result;
72286
72287   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72288   jresult = (int)result;
72289   return jresult;
72290 }
72291
72292
72293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72294   int jresult ;
72295   int result;
72296
72297   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72298   jresult = (int)result;
72299   return jresult;
72300 }
72301
72302
72303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72304   int jresult ;
72305   int result;
72306
72307   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72308   jresult = (int)result;
72309   return jresult;
72310 }
72311
72312
72313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72314   int jresult ;
72315   int result;
72316
72317   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72318   jresult = (int)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72324   int jresult ;
72325   int result;
72326
72327   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72328   jresult = (int)result;
72329   return jresult;
72330 }
72331
72332
72333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72334   int jresult ;
72335   int result;
72336
72337   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72338   jresult = (int)result;
72339   return jresult;
72340 }
72341
72342
72343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72344   int jresult ;
72345   int result;
72346
72347   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72348   jresult = (int)result;
72349   return jresult;
72350 }
72351
72352
72353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72354   int jresult ;
72355   int result;
72356
72357   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72358   jresult = (int)result;
72359   return jresult;
72360 }
72361
72362
72363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72364   int jresult ;
72365   int result;
72366
72367   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72368   jresult = (int)result;
72369   return jresult;
72370 }
72371
72372
72373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72374   int jresult ;
72375   int result;
72376
72377   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72378   jresult = (int)result;
72379   return jresult;
72380 }
72381
72382
72383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72384   int jresult ;
72385   int result;
72386
72387   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72388   jresult = (int)result;
72389   return jresult;
72390 }
72391
72392
72393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72394   int jresult ;
72395   int result;
72396
72397   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72398   jresult = (int)result;
72399   return jresult;
72400 }
72401
72402
72403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72404   void * jresult ;
72405   Dali::Toolkit::Scrollable::Property *result = 0 ;
72406
72407   {
72408     try {
72409       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72410     } catch (std::out_of_range& e) {
72411       {
72412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72413       };
72414     } catch (std::exception& e) {
72415       {
72416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72417       };
72418     } catch (Dali::DaliException e) {
72419       {
72420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72421       };
72422     } catch (...) {
72423       {
72424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72425       };
72426     }
72427   }
72428
72429   jresult = (void *)result;
72430   return jresult;
72431 }
72432
72433
72434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72435   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72436
72437   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72438   {
72439     try {
72440       delete arg1;
72441     } catch (std::out_of_range& e) {
72442       {
72443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72444       };
72445     } catch (std::exception& e) {
72446       {
72447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72448       };
72449     } catch (Dali::DaliException e) {
72450       {
72451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72452       };
72453     } catch (...) {
72454       {
72455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72456       };
72457     }
72458   }
72459
72460 }
72461
72462
72463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72464   void * jresult ;
72465   Dali::Toolkit::Scrollable *result = 0 ;
72466
72467   {
72468     try {
72469       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72470     } catch (std::out_of_range& e) {
72471       {
72472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72473       };
72474     } catch (std::exception& e) {
72475       {
72476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72477       };
72478     } catch (Dali::DaliException e) {
72479       {
72480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72481       };
72482     } catch (...) {
72483       {
72484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72485       };
72486     }
72487   }
72488
72489   jresult = (void *)result;
72490   return jresult;
72491 }
72492
72493
72494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72495   void * jresult ;
72496   Dali::Toolkit::Scrollable *arg1 = 0 ;
72497   Dali::Toolkit::Scrollable *result = 0 ;
72498
72499   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72500   if (!arg1) {
72501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72502     return 0;
72503   }
72504   {
72505     try {
72506       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72507     } catch (std::out_of_range& e) {
72508       {
72509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72510       };
72511     } catch (std::exception& e) {
72512       {
72513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72514       };
72515     } catch (Dali::DaliException e) {
72516       {
72517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72518       };
72519     } catch (...) {
72520       {
72521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72522       };
72523     }
72524   }
72525
72526   jresult = (void *)result;
72527   return jresult;
72528 }
72529
72530
72531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72532   void * jresult ;
72533   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72534   Dali::Toolkit::Scrollable *arg2 = 0 ;
72535   Dali::Toolkit::Scrollable *result = 0 ;
72536
72537   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72538   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72539   if (!arg2) {
72540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72541     return 0;
72542   }
72543   {
72544     try {
72545       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72546     } catch (std::out_of_range& e) {
72547       {
72548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72549       };
72550     } catch (std::exception& e) {
72551       {
72552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72553       };
72554     } catch (Dali::DaliException e) {
72555       {
72556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72557       };
72558     } catch (...) {
72559       {
72560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72561       };
72562     }
72563   }
72564
72565   jresult = (void *)result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72571   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72572
72573   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72574   {
72575     try {
72576       delete arg1;
72577     } catch (std::out_of_range& e) {
72578       {
72579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72580       };
72581     } catch (std::exception& e) {
72582       {
72583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72584       };
72585     } catch (Dali::DaliException e) {
72586       {
72587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72588       };
72589     } catch (...) {
72590       {
72591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72592       };
72593     }
72594   }
72595
72596 }
72597
72598
72599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72600   void * jresult ;
72601   Dali::BaseHandle arg1 ;
72602   Dali::BaseHandle *argp1 ;
72603   Dali::Toolkit::Scrollable result;
72604
72605   argp1 = (Dali::BaseHandle *)jarg1;
72606   if (!argp1) {
72607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72608     return 0;
72609   }
72610   arg1 = *argp1;
72611   {
72612     try {
72613       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72614     } catch (std::out_of_range& e) {
72615       {
72616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72617       };
72618     } catch (std::exception& e) {
72619       {
72620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72621       };
72622     } catch (Dali::DaliException e) {
72623       {
72624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72625       };
72626     } catch (...) {
72627       {
72628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72629       };
72630     }
72631   }
72632
72633   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72639   unsigned int jresult ;
72640   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72641   bool result;
72642
72643   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72644   {
72645     try {
72646       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72647     } catch (std::out_of_range& e) {
72648       {
72649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72650       };
72651     } catch (std::exception& e) {
72652       {
72653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72654       };
72655     } catch (Dali::DaliException e) {
72656       {
72657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72658       };
72659     } catch (...) {
72660       {
72661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72662       };
72663     }
72664   }
72665
72666   jresult = result;
72667   return jresult;
72668 }
72669
72670
72671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72672   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72673   bool arg2 ;
72674
72675   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72676   arg2 = jarg2 ? true : false;
72677   {
72678     try {
72679       (arg1)->SetOvershootEnabled(arg2);
72680     } catch (std::out_of_range& e) {
72681       {
72682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72683       };
72684     } catch (std::exception& e) {
72685       {
72686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72687       };
72688     } catch (Dali::DaliException e) {
72689       {
72690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72691       };
72692     } catch (...) {
72693       {
72694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72695       };
72696     }
72697   }
72698
72699 }
72700
72701
72702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
72703   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72704   Dali::Vector4 *arg2 = 0 ;
72705
72706   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72707   arg2 = (Dali::Vector4 *)jarg2;
72708   if (!arg2) {
72709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
72710     return ;
72711   }
72712   {
72713     try {
72714       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
72715     } catch (std::out_of_range& e) {
72716       {
72717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72718       };
72719     } catch (std::exception& e) {
72720       {
72721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72722       };
72723     } catch (Dali::DaliException e) {
72724       {
72725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72726       };
72727     } catch (...) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72730       };
72731     }
72732   }
72733
72734 }
72735
72736
72737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
72738   void * jresult ;
72739   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72740   Dali::Vector4 result;
72741
72742   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72743   {
72744     try {
72745       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
72746     } catch (std::out_of_range& e) {
72747       {
72748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72749       };
72750     } catch (std::exception& e) {
72751       {
72752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72753       };
72754     } catch (Dali::DaliException e) {
72755       {
72756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72761       };
72762     }
72763   }
72764
72765   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
72771   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72772   float arg2 ;
72773
72774   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72775   arg2 = (float)jarg2;
72776   {
72777     try {
72778       (arg1)->SetOvershootAnimationSpeed(arg2);
72779     } catch (std::out_of_range& e) {
72780       {
72781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72782       };
72783     } catch (std::exception& e) {
72784       {
72785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72786       };
72787     } catch (Dali::DaliException e) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72790       };
72791     } catch (...) {
72792       {
72793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72794       };
72795     }
72796   }
72797
72798 }
72799
72800
72801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
72802   float jresult ;
72803   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72804   float result;
72805
72806   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72807   {
72808     try {
72809       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
72810     } catch (std::out_of_range& e) {
72811       {
72812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72813       };
72814     } catch (std::exception& e) {
72815       {
72816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72817       };
72818     } catch (Dali::DaliException e) {
72819       {
72820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72821       };
72822     } catch (...) {
72823       {
72824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72825       };
72826     }
72827   }
72828
72829   jresult = result;
72830   return jresult;
72831 }
72832
72833
72834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
72835   void * jresult ;
72836   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72837   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
72838
72839   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72840   {
72841     try {
72842       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
72843     } catch (std::out_of_range& e) {
72844       {
72845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72846       };
72847     } catch (std::exception& e) {
72848       {
72849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72850       };
72851     } catch (Dali::DaliException e) {
72852       {
72853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72854       };
72855     } catch (...) {
72856       {
72857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72858       };
72859     }
72860   }
72861
72862   jresult = (void *)result;
72863   return jresult;
72864 }
72865
72866
72867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
72868   void * jresult ;
72869   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72870   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
72871
72872   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72873   {
72874     try {
72875       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
72876     } catch (std::out_of_range& e) {
72877       {
72878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72879       };
72880     } catch (std::exception& e) {
72881       {
72882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72883       };
72884     } catch (Dali::DaliException e) {
72885       {
72886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72887       };
72888     } catch (...) {
72889       {
72890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72891       };
72892     }
72893   }
72894
72895   jresult = (void *)result;
72896   return jresult;
72897 }
72898
72899
72900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
72901   void * jresult ;
72902   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72903   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
72904
72905   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72906   {
72907     try {
72908       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
72909     } catch (std::out_of_range& e) {
72910       {
72911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72912       };
72913     } catch (std::exception& e) {
72914       {
72915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72916       };
72917     } catch (Dali::DaliException e) {
72918       {
72919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72920       };
72921     } catch (...) {
72922       {
72923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72924       };
72925     }
72926   }
72927
72928   jresult = (void *)result;
72929   return jresult;
72930 }
72931
72932
72933 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
72934   unsigned int jresult ;
72935   Dali::Toolkit::ControlOrientation::Type arg1 ;
72936   bool result;
72937
72938   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
72939   {
72940     try {
72941       result = (bool)Dali::Toolkit::IsVertical(arg1);
72942     } catch (std::out_of_range& e) {
72943       {
72944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72945       };
72946     } catch (std::exception& e) {
72947       {
72948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72949       };
72950     } catch (Dali::DaliException e) {
72951       {
72952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72953       };
72954     } catch (...) {
72955       {
72956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72957       };
72958     }
72959   }
72960
72961   jresult = result;
72962   return jresult;
72963 }
72964
72965
72966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
72967   unsigned int jresult ;
72968   Dali::Toolkit::ControlOrientation::Type arg1 ;
72969   bool result;
72970
72971   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
72972   {
72973     try {
72974       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
72975     } catch (std::out_of_range& e) {
72976       {
72977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72978       };
72979     } catch (std::exception& e) {
72980       {
72981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72982       };
72983     } catch (Dali::DaliException e) {
72984       {
72985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72986       };
72987     } catch (...) {
72988       {
72989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72990       };
72991     }
72992   }
72993
72994   jresult = result;
72995   return jresult;
72996 }
72997
72998
72999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73000   void * jresult ;
73001   unsigned int arg1 ;
73002   unsigned int arg2 ;
73003   Dali::Toolkit::ItemRange *result = 0 ;
73004
73005   arg1 = (unsigned int)jarg1;
73006   arg2 = (unsigned int)jarg2;
73007   {
73008     try {
73009       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73010     } catch (std::out_of_range& e) {
73011       {
73012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73013       };
73014     } catch (std::exception& e) {
73015       {
73016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73017       };
73018     } catch (Dali::DaliException e) {
73019       {
73020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73021       };
73022     } catch (...) {
73023       {
73024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73025       };
73026     }
73027   }
73028
73029   jresult = (void *)result;
73030   return jresult;
73031 }
73032
73033
73034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73035   void * jresult ;
73036   Dali::Toolkit::ItemRange *arg1 = 0 ;
73037   Dali::Toolkit::ItemRange *result = 0 ;
73038
73039   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73040   if (!arg1) {
73041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73042     return 0;
73043   }
73044   {
73045     try {
73046       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73047     } catch (std::out_of_range& e) {
73048       {
73049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73050       };
73051     } catch (std::exception& e) {
73052       {
73053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73054       };
73055     } catch (Dali::DaliException e) {
73056       {
73057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73058       };
73059     } catch (...) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73062       };
73063     }
73064   }
73065
73066   jresult = (void *)result;
73067   return jresult;
73068 }
73069
73070
73071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73072   void * jresult ;
73073   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73074   Dali::Toolkit::ItemRange *arg2 = 0 ;
73075   Dali::Toolkit::ItemRange *result = 0 ;
73076
73077   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73078   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73079   if (!arg2) {
73080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73081     return 0;
73082   }
73083   {
73084     try {
73085       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73086     } catch (std::out_of_range& e) {
73087       {
73088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73089       };
73090     } catch (std::exception& e) {
73091       {
73092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73093       };
73094     } catch (Dali::DaliException e) {
73095       {
73096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73097       };
73098     } catch (...) {
73099       {
73100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73101       };
73102     }
73103   }
73104
73105   jresult = (void *)result;
73106   return jresult;
73107 }
73108
73109
73110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73111   unsigned int jresult ;
73112   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73113   unsigned int arg2 ;
73114   bool result;
73115
73116   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73117   arg2 = (unsigned int)jarg2;
73118   {
73119     try {
73120       result = (bool)(arg1)->Within(arg2);
73121     } catch (std::out_of_range& e) {
73122       {
73123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73124       };
73125     } catch (std::exception& e) {
73126       {
73127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73128       };
73129     } catch (Dali::DaliException e) {
73130       {
73131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73132       };
73133     } catch (...) {
73134       {
73135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73136       };
73137     }
73138   }
73139
73140   jresult = result;
73141   return jresult;
73142 }
73143
73144
73145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73146   void * jresult ;
73147   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73148   Dali::Toolkit::ItemRange *arg2 = 0 ;
73149   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73150
73151   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73152   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73153   if (!arg2) {
73154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73155     return 0;
73156   }
73157   {
73158     try {
73159       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73160     } catch (std::out_of_range& e) {
73161       {
73162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73163       };
73164     } catch (std::exception& e) {
73165       {
73166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73167       };
73168     } catch (Dali::DaliException e) {
73169       {
73170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73171       };
73172     } catch (...) {
73173       {
73174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73175       };
73176     }
73177   }
73178
73179   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73180   return jresult;
73181 }
73182
73183
73184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73185   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73186   unsigned int arg2 ;
73187
73188   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73189   arg2 = (unsigned int)jarg2;
73190   if (arg1) (arg1)->begin = arg2;
73191 }
73192
73193
73194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73195   unsigned int jresult ;
73196   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73197   unsigned int result;
73198
73199   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73200   result = (unsigned int) ((arg1)->begin);
73201   jresult = result;
73202   return jresult;
73203 }
73204
73205
73206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73207   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73208   unsigned int arg2 ;
73209
73210   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73211   arg2 = (unsigned int)jarg2;
73212   if (arg1) (arg1)->end = arg2;
73213 }
73214
73215
73216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73217   unsigned int jresult ;
73218   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73219   unsigned int result;
73220
73221   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73222   result = (unsigned int) ((arg1)->end);
73223   jresult = result;
73224   return jresult;
73225 }
73226
73227
73228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73229   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73230
73231   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73232   {
73233     try {
73234       delete arg1;
73235     } catch (std::out_of_range& e) {
73236       {
73237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73238       };
73239     } catch (std::exception& e) {
73240       {
73241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73242       };
73243     } catch (Dali::DaliException e) {
73244       {
73245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73246       };
73247     } catch (...) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73250       };
73251     }
73252   }
73253
73254 }
73255
73256
73257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73258   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73259
73260   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73261   {
73262     try {
73263       delete arg1;
73264     } catch (std::out_of_range& e) {
73265       {
73266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73267       };
73268     } catch (std::exception& e) {
73269       {
73270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73271       };
73272     } catch (Dali::DaliException e) {
73273       {
73274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73275       };
73276     } catch (...) {
73277       {
73278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73279       };
73280     }
73281   }
73282
73283 }
73284
73285
73286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73287   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73288   Dali::Toolkit::ControlOrientation::Type arg2 ;
73289
73290   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73291   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73292   {
73293     try {
73294       (arg1)->SetOrientation(arg2);
73295     } catch (std::out_of_range& e) {
73296       {
73297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73298       };
73299     } catch (std::exception& e) {
73300       {
73301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73302       };
73303     } catch (Dali::DaliException e) {
73304       {
73305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73306       };
73307     } catch (...) {
73308       {
73309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73310       };
73311     }
73312   }
73313
73314 }
73315
73316
73317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73318   int jresult ;
73319   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73320   Dali::Toolkit::ControlOrientation::Type result;
73321
73322   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73323   {
73324     try {
73325       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73326     } catch (std::out_of_range& e) {
73327       {
73328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73329       };
73330     } catch (std::exception& e) {
73331       {
73332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73333       };
73334     } catch (Dali::DaliException e) {
73335       {
73336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73337       };
73338     } catch (...) {
73339       {
73340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73341       };
73342     }
73343   }
73344
73345   jresult = (int)result;
73346   return jresult;
73347 }
73348
73349
73350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73351   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73352   Dali::Property::Map *arg2 = 0 ;
73353
73354   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73355   arg2 = (Dali::Property::Map *)jarg2;
73356   if (!arg2) {
73357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73358     return ;
73359   }
73360   {
73361     try {
73362       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73363     } catch (std::out_of_range& e) {
73364       {
73365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73366       };
73367     } catch (std::exception& e) {
73368       {
73369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73370       };
73371     } catch (Dali::DaliException e) {
73372       {
73373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73374       };
73375     } catch (...) {
73376       {
73377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73378       };
73379     }
73380   }
73381
73382 }
73383
73384
73385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73386   void * jresult ;
73387   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73388   Dali::Property::Map result;
73389
73390   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73391   {
73392     try {
73393       result = (arg1)->GetLayoutProperties();
73394     } catch (std::out_of_range& e) {
73395       {
73396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73397       };
73398     } catch (std::exception& e) {
73399       {
73400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73401       };
73402     } catch (Dali::DaliException e) {
73403       {
73404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73405       };
73406     } catch (...) {
73407       {
73408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73409       };
73410     }
73411   }
73412
73413   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73414   return jresult;
73415 }
73416
73417
73418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73419   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73420   unsigned int arg2 ;
73421   Dali::Vector3 *arg3 = 0 ;
73422   Dali::Vector3 *arg4 = 0 ;
73423
73424   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73425   arg2 = (unsigned int)jarg2;
73426   arg3 = (Dali::Vector3 *)jarg3;
73427   if (!arg3) {
73428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73429     return ;
73430   }
73431   arg4 = (Dali::Vector3 *)jarg4;
73432   if (!arg4) {
73433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73434     return ;
73435   }
73436   {
73437     try {
73438       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73439     } catch (std::out_of_range& e) {
73440       {
73441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73442       };
73443     } catch (std::exception& e) {
73444       {
73445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73446       };
73447     } catch (Dali::DaliException e) {
73448       {
73449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73450       };
73451     } catch (...) {
73452       {
73453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73454       };
73455     }
73456   }
73457
73458 }
73459
73460
73461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73462   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73463   Dali::Vector3 *arg2 = 0 ;
73464
73465   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73466   arg2 = (Dali::Vector3 *)jarg2;
73467   if (!arg2) {
73468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73469     return ;
73470   }
73471   {
73472     try {
73473       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73474     } catch (std::out_of_range& e) {
73475       {
73476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73477       };
73478     } catch (std::exception& e) {
73479       {
73480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73481       };
73482     } catch (Dali::DaliException e) {
73483       {
73484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73485       };
73486     } catch (...) {
73487       {
73488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73489       };
73490     }
73491   }
73492
73493 }
73494
73495
73496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73497   float jresult ;
73498   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73499   unsigned int arg2 ;
73500   Dali::Vector3 arg3 ;
73501   Dali::Vector3 *argp3 ;
73502   float result;
73503
73504   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73505   arg2 = (unsigned int)jarg2;
73506   argp3 = (Dali::Vector3 *)jarg3;
73507   if (!argp3) {
73508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73509     return 0;
73510   }
73511   arg3 = *argp3;
73512   {
73513     try {
73514       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73515     } catch (std::out_of_range& e) {
73516       {
73517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (std::exception& e) {
73520       {
73521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73522       };
73523     } catch (Dali::DaliException e) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73526       };
73527     } catch (...) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73530       };
73531     }
73532   }
73533
73534   jresult = result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73540   float jresult ;
73541   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73542   float arg2 ;
73543   float result;
73544
73545   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73546   arg2 = (float)jarg2;
73547   {
73548     try {
73549       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73550     } catch (std::out_of_range& e) {
73551       {
73552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (std::exception& e) {
73555       {
73556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73557       };
73558     } catch (Dali::DaliException e) {
73559       {
73560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73561       };
73562     } catch (...) {
73563       {
73564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73565       };
73566     }
73567   }
73568
73569   jresult = result;
73570   return jresult;
73571 }
73572
73573
73574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73575   float jresult ;
73576   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73577   unsigned int arg2 ;
73578   float result;
73579
73580   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73581   arg2 = (unsigned int)jarg2;
73582   {
73583     try {
73584       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73585     } catch (std::out_of_range& e) {
73586       {
73587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73588       };
73589     } catch (std::exception& e) {
73590       {
73591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73592       };
73593     } catch (Dali::DaliException e) {
73594       {
73595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73596       };
73597     } catch (...) {
73598       {
73599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73600       };
73601     }
73602   }
73603
73604   jresult = result;
73605   return jresult;
73606 }
73607
73608
73609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73610   void * jresult ;
73611   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73612   float arg2 ;
73613   Dali::Vector3 arg3 ;
73614   Dali::Vector3 *argp3 ;
73615   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73616
73617   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73618   arg2 = (float)jarg2;
73619   argp3 = (Dali::Vector3 *)jarg3;
73620   if (!argp3) {
73621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73622     return 0;
73623   }
73624   arg3 = *argp3;
73625   {
73626     try {
73627       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73628     } catch (std::out_of_range& e) {
73629       {
73630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73631       };
73632     } catch (std::exception& e) {
73633       {
73634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (Dali::DaliException e) {
73637       {
73638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73643       };
73644     }
73645   }
73646
73647   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73648   return jresult;
73649 }
73650
73651
73652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73653   float jresult ;
73654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73655   int arg2 ;
73656   float arg3 ;
73657   Dali::Vector3 *arg4 = 0 ;
73658   float result;
73659
73660   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73661   arg2 = (int)jarg2;
73662   arg3 = (float)jarg3;
73663   arg4 = (Dali::Vector3 *)jarg4;
73664   if (!arg4) {
73665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73666     return 0;
73667   }
73668   {
73669     try {
73670       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73671     } catch (std::out_of_range& e) {
73672       {
73673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73674       };
73675     } catch (std::exception& e) {
73676       {
73677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73678       };
73679     } catch (Dali::DaliException e) {
73680       {
73681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73682       };
73683     } catch (...) {
73684       {
73685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73686       };
73687     }
73688   }
73689
73690   jresult = result;
73691   return jresult;
73692 }
73693
73694
73695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73696   unsigned int jresult ;
73697   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73698   Dali::Vector3 arg2 ;
73699   Dali::Vector3 *argp2 ;
73700   unsigned int result;
73701
73702   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73703   argp2 = (Dali::Vector3 *)jarg2;
73704   if (!argp2) {
73705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73706     return 0;
73707   }
73708   arg2 = *argp2;
73709   {
73710     try {
73711       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
73712     } catch (std::out_of_range& e) {
73713       {
73714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (std::exception& e) {
73717       {
73718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73719       };
73720     } catch (Dali::DaliException e) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73723       };
73724     } catch (...) {
73725       {
73726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73727       };
73728     }
73729   }
73730
73731   jresult = result;
73732   return jresult;
73733 }
73734
73735
73736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73737   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73738   unsigned int arg2 ;
73739   Dali::Vector3 *arg3 = 0 ;
73740   Dali::Vector3 *arg4 = 0 ;
73741
73742   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73743   arg2 = (unsigned int)jarg2;
73744   arg3 = (Dali::Vector3 *)jarg3;
73745   if (!arg3) {
73746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73747     return ;
73748   }
73749   arg4 = (Dali::Vector3 *)jarg4;
73750   if (!arg4) {
73751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73752     return ;
73753   }
73754   {
73755     try {
73756       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73757     } catch (std::out_of_range& e) {
73758       {
73759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73760       };
73761     } catch (std::exception& e) {
73762       {
73763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73764       };
73765     } catch (Dali::DaliException e) {
73766       {
73767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73768       };
73769     } catch (...) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73772       };
73773     }
73774   }
73775
73776 }
73777
73778
73779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
73780   void * jresult ;
73781   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73782   Dali::Degree result;
73783
73784   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73785   {
73786     try {
73787       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
73788     } catch (std::out_of_range& e) {
73789       {
73790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73791       };
73792     } catch (std::exception& e) {
73793       {
73794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73795       };
73796     } catch (Dali::DaliException e) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73803       };
73804     }
73805   }
73806
73807   jresult = new Dali::Degree((const Dali::Degree &)result);
73808   return jresult;
73809 }
73810
73811
73812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
73813   float jresult ;
73814   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73815   float result;
73816
73817   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73818   {
73819     try {
73820       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
73821     } catch (std::out_of_range& e) {
73822       {
73823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (std::exception& e) {
73826       {
73827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73828       };
73829     } catch (Dali::DaliException e) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73832       };
73833     } catch (...) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73836       };
73837     }
73838   }
73839
73840   jresult = result;
73841   return jresult;
73842 }
73843
73844
73845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
73846   float jresult ;
73847   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73848   float result;
73849
73850   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73851   {
73852     try {
73853       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
73854     } catch (std::out_of_range& e) {
73855       {
73856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73857       };
73858     } catch (std::exception& e) {
73859       {
73860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73861       };
73862     } catch (Dali::DaliException e) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73865       };
73866     } catch (...) {
73867       {
73868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73869       };
73870     }
73871   }
73872
73873   jresult = result;
73874   return jresult;
73875 }
73876
73877
73878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
73879   float jresult ;
73880   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73881   float result;
73882
73883   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73884   {
73885     try {
73886       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73894       };
73895     } catch (Dali::DaliException e) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73898       };
73899     } catch (...) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73902       };
73903     }
73904   }
73905
73906   jresult = result;
73907   return jresult;
73908 }
73909
73910
73911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
73912   int jresult ;
73913   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73914   int arg2 ;
73915   int arg3 ;
73916   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
73917   bool arg5 ;
73918   int result;
73919
73920   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73921   arg2 = (int)jarg2;
73922   arg3 = (int)jarg3;
73923   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
73924   arg5 = jarg5 ? true : false;
73925   {
73926     try {
73927       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
73928     } catch (std::out_of_range& e) {
73929       {
73930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73931       };
73932     } catch (std::exception& e) {
73933       {
73934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73935       };
73936     } catch (Dali::DaliException e) {
73937       {
73938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73939       };
73940     } catch (...) {
73941       {
73942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73943       };
73944     }
73945   }
73946
73947   jresult = result;
73948   return jresult;
73949 }
73950
73951
73952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
73953   float jresult ;
73954   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73955   float result;
73956
73957   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73958   {
73959     try {
73960       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
73961     } catch (std::out_of_range& e) {
73962       {
73963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73964       };
73965     } catch (std::exception& e) {
73966       {
73967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (Dali::DaliException e) {
73970       {
73971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73972       };
73973     } catch (...) {
73974       {
73975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73976       };
73977     }
73978   }
73979
73980   jresult = result;
73981   return jresult;
73982 }
73983
73984
73985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
73986   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73987   Dali::Actor *arg2 = 0 ;
73988   int arg3 ;
73989   Dali::Vector3 *arg4 = 0 ;
73990   Dali::Actor *arg5 = 0 ;
73991
73992   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73993   arg2 = (Dali::Actor *)jarg2;
73994   if (!arg2) {
73995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
73996     return ;
73997   }
73998   arg3 = (int)jarg3;
73999   arg4 = (Dali::Vector3 *)jarg4;
74000   if (!arg4) {
74001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74002     return ;
74003   }
74004   arg5 = (Dali::Actor *)jarg5;
74005   if (!arg5) {
74006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74007     return ;
74008   }
74009   {
74010     try {
74011       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74012     } catch (std::out_of_range& e) {
74013       {
74014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74015       };
74016     } catch (std::exception& e) {
74017       {
74018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74019       };
74020     } catch (Dali::DaliException e) {
74021       {
74022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74027       };
74028     }
74029   }
74030
74031 }
74032
74033
74034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74035   void * jresult ;
74036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74037   int arg2 ;
74038   float arg3 ;
74039   Dali::Vector3 *arg4 = 0 ;
74040   Dali::Vector3 result;
74041
74042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74043   arg2 = (int)jarg2;
74044   arg3 = (float)jarg3;
74045   arg4 = (Dali::Vector3 *)jarg4;
74046   if (!arg4) {
74047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74048     return 0;
74049   }
74050   {
74051     try {
74052       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74053     } catch (std::out_of_range& e) {
74054       {
74055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74056       };
74057     } catch (std::exception& e) {
74058       {
74059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74060       };
74061     } catch (Dali::DaliException e) {
74062       {
74063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74064       };
74065     } catch (...) {
74066       {
74067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74068       };
74069     }
74070   }
74071
74072   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74073   return jresult;
74074 }
74075
74076
74077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74078   void * jresult ;
74079   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74080   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74081
74082   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74083   {
74084     try {
74085       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74086     } catch (std::out_of_range& e) {
74087       {
74088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74089       };
74090     } catch (std::exception& e) {
74091       {
74092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74093       };
74094     } catch (Dali::DaliException e) {
74095       {
74096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74097       };
74098     } catch (...) {
74099       {
74100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74101       };
74102     }
74103   }
74104
74105   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74106   return jresult;
74107 }
74108
74109
74110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74111   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74112
74113   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74114   {
74115     try {
74116       delete arg1;
74117     } catch (std::out_of_range& e) {
74118       {
74119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74120       };
74121     } catch (std::exception& e) {
74122       {
74123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74124       };
74125     } catch (Dali::DaliException e) {
74126       {
74127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74132       };
74133     }
74134   }
74135
74136 }
74137
74138
74139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74140   unsigned int jresult ;
74141   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74142   unsigned int result;
74143
74144   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74145   {
74146     try {
74147       result = (unsigned int)(arg1)->GetNumberOfItems();
74148     } catch (std::out_of_range& e) {
74149       {
74150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74151       };
74152     } catch (std::exception& e) {
74153       {
74154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74155       };
74156     } catch (Dali::DaliException e) {
74157       {
74158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74159       };
74160     } catch (...) {
74161       {
74162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74163       };
74164     }
74165   }
74166
74167   jresult = result;
74168   return jresult;
74169 }
74170
74171
74172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74173   void * jresult ;
74174   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74175   unsigned int arg2 ;
74176   Dali::Actor result;
74177
74178   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74179   arg2 = (unsigned int)jarg2;
74180   {
74181     try {
74182       result = (arg1)->NewItem(arg2);
74183     } catch (std::out_of_range& e) {
74184       {
74185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74186       };
74187     } catch (std::exception& e) {
74188       {
74189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74190       };
74191     } catch (Dali::DaliException e) {
74192       {
74193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74194       };
74195     } catch (...) {
74196       {
74197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74198       };
74199     }
74200   }
74201
74202   jresult = new Dali::Actor((const Dali::Actor &)result);
74203   return jresult;
74204 }
74205
74206
74207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74208   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74209   unsigned int arg2 ;
74210   Dali::Actor arg3 ;
74211   Dali::Actor *argp3 ;
74212
74213   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74214   arg2 = (unsigned int)jarg2;
74215   argp3 = (Dali::Actor *)jarg3;
74216   if (!argp3) {
74217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74218     return ;
74219   }
74220   arg3 = *argp3;
74221   {
74222     try {
74223       (arg1)->ItemReleased(arg2,arg3);
74224     } catch (std::out_of_range& e) {
74225       {
74226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74227       };
74228     } catch (std::exception& e) {
74229       {
74230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74231       };
74232     } catch (Dali::DaliException e) {
74233       {
74234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74235       };
74236     } catch (...) {
74237       {
74238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74239       };
74240     }
74241   }
74242
74243 }
74244
74245
74246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74247   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74248   unsigned int arg2 ;
74249   Dali::Actor arg3 ;
74250   Dali::Actor *argp3 ;
74251
74252   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74253   arg2 = (unsigned int)jarg2;
74254   argp3 = (Dali::Actor *)jarg3;
74255   if (!argp3) {
74256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74257     return ;
74258   }
74259   arg3 = *argp3;
74260   {
74261     try {
74262       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74263     } catch (std::out_of_range& e) {
74264       {
74265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74266       };
74267     } catch (std::exception& e) {
74268       {
74269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74270       };
74271     } catch (Dali::DaliException e) {
74272       {
74273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74274       };
74275     } catch (...) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74278       };
74279     }
74280   }
74281
74282 }
74283
74284
74285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74286   void * jresult ;
74287   Dali::Toolkit::ItemFactory *result = 0 ;
74288
74289   {
74290     try {
74291       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74292     } catch (std::out_of_range& e) {
74293       {
74294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74295       };
74296     } catch (std::exception& e) {
74297       {
74298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74299       };
74300     } catch (Dali::DaliException e) {
74301       {
74302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74303       };
74304     } catch (...) {
74305       {
74306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74307       };
74308     }
74309   }
74310
74311   jresult = (void *)result;
74312   return jresult;
74313 }
74314
74315
74316 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) {
74317   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74318   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74319   if (director) {
74320     director->swig_connect_director(callback0, callback1, callback2);
74321   }
74322 }
74323
74324
74325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74326   int jresult ;
74327   int result;
74328
74329   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74330   jresult = (int)result;
74331   return jresult;
74332 }
74333
74334
74335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74336   int jresult ;
74337   int result;
74338
74339   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74340   jresult = (int)result;
74341   return jresult;
74342 }
74343
74344
74345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74346   int jresult ;
74347   int result;
74348
74349   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74350   jresult = (int)result;
74351   return jresult;
74352 }
74353
74354
74355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74356   int jresult ;
74357   int result;
74358
74359   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74360   jresult = (int)result;
74361   return jresult;
74362 }
74363
74364
74365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74366   int jresult ;
74367   int result;
74368
74369   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74370   jresult = (int)result;
74371   return jresult;
74372 }
74373
74374
74375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74376   int jresult ;
74377   int result;
74378
74379   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74380   jresult = (int)result;
74381   return jresult;
74382 }
74383
74384
74385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74386   int jresult ;
74387   int result;
74388
74389   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74390   jresult = (int)result;
74391   return jresult;
74392 }
74393
74394
74395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74396   int jresult ;
74397   int result;
74398
74399   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74400   jresult = (int)result;
74401   return jresult;
74402 }
74403
74404
74405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74406   int jresult ;
74407   int result;
74408
74409   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74410   jresult = (int)result;
74411   return jresult;
74412 }
74413
74414
74415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74416   int jresult ;
74417   int result;
74418
74419   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74420   jresult = (int)result;
74421   return jresult;
74422 }
74423
74424
74425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74426   int jresult ;
74427   int result;
74428
74429   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74430   jresult = (int)result;
74431   return jresult;
74432 }
74433
74434
74435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74436   void * jresult ;
74437   Dali::Toolkit::ItemView::Property *result = 0 ;
74438
74439   {
74440     try {
74441       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74442     } catch (std::out_of_range& e) {
74443       {
74444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74445       };
74446     } catch (std::exception& e) {
74447       {
74448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74449       };
74450     } catch (Dali::DaliException e) {
74451       {
74452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74453       };
74454     } catch (...) {
74455       {
74456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74457       };
74458     }
74459   }
74460
74461   jresult = (void *)result;
74462   return jresult;
74463 }
74464
74465
74466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74467   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74468
74469   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74470   {
74471     try {
74472       delete arg1;
74473     } catch (std::out_of_range& e) {
74474       {
74475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74476       };
74477     } catch (std::exception& e) {
74478       {
74479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (Dali::DaliException e) {
74482       {
74483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74484       };
74485     } catch (...) {
74486       {
74487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74488       };
74489     }
74490   }
74491
74492 }
74493
74494
74495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74496   void * jresult ;
74497   Dali::Toolkit::ItemView *result = 0 ;
74498
74499   {
74500     try {
74501       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74502     } catch (std::out_of_range& e) {
74503       {
74504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74505       };
74506     } catch (std::exception& e) {
74507       {
74508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74509       };
74510     } catch (Dali::DaliException e) {
74511       {
74512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74513       };
74514     } catch (...) {
74515       {
74516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74517       };
74518     }
74519   }
74520
74521   jresult = (void *)result;
74522   return jresult;
74523 }
74524
74525
74526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74527   void * jresult ;
74528   Dali::Toolkit::ItemView *arg1 = 0 ;
74529   Dali::Toolkit::ItemView *result = 0 ;
74530
74531   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74532   if (!arg1) {
74533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74534     return 0;
74535   }
74536   {
74537     try {
74538       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74539     } catch (std::out_of_range& e) {
74540       {
74541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74542       };
74543     } catch (std::exception& e) {
74544       {
74545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74546       };
74547     } catch (Dali::DaliException e) {
74548       {
74549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74550       };
74551     } catch (...) {
74552       {
74553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74554       };
74555     }
74556   }
74557
74558   jresult = (void *)result;
74559   return jresult;
74560 }
74561
74562
74563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74564   void * jresult ;
74565   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74566   Dali::Toolkit::ItemView *arg2 = 0 ;
74567   Dali::Toolkit::ItemView *result = 0 ;
74568
74569   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74570   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74571   if (!arg2) {
74572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74573     return 0;
74574   }
74575   {
74576     try {
74577       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74578     } catch (std::out_of_range& e) {
74579       {
74580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74581       };
74582     } catch (std::exception& e) {
74583       {
74584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74585       };
74586     } catch (Dali::DaliException e) {
74587       {
74588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74589       };
74590     } catch (...) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74593       };
74594     }
74595   }
74596
74597   jresult = (void *)result;
74598   return jresult;
74599 }
74600
74601
74602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74604
74605   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74606   {
74607     try {
74608       delete arg1;
74609     } catch (std::out_of_range& e) {
74610       {
74611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74612       };
74613     } catch (std::exception& e) {
74614       {
74615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74616       };
74617     } catch (Dali::DaliException e) {
74618       {
74619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74620       };
74621     } catch (...) {
74622       {
74623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74624       };
74625     }
74626   }
74627
74628 }
74629
74630
74631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74632   void * jresult ;
74633   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74634   Dali::Toolkit::ItemView result;
74635
74636   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74637   if (!arg1) {
74638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74639     return 0;
74640   }
74641   {
74642     try {
74643       result = Dali::Toolkit::ItemView::New(*arg1);
74644     } catch (std::out_of_range& e) {
74645       {
74646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74647       };
74648     } catch (std::exception& e) {
74649       {
74650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74651       };
74652     } catch (Dali::DaliException e) {
74653       {
74654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74655       };
74656     } catch (...) {
74657       {
74658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74659       };
74660     }
74661   }
74662
74663   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74664   return jresult;
74665 }
74666
74667
74668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74669   void * jresult ;
74670   Dali::BaseHandle arg1 ;
74671   Dali::BaseHandle *argp1 ;
74672   Dali::Toolkit::ItemView result;
74673
74674   argp1 = (Dali::BaseHandle *)jarg1;
74675   if (!argp1) {
74676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74677     return 0;
74678   }
74679   arg1 = *argp1;
74680   {
74681     try {
74682       result = Dali::Toolkit::ItemView::DownCast(arg1);
74683     } catch (std::out_of_range& e) {
74684       {
74685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74686       };
74687     } catch (std::exception& e) {
74688       {
74689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74690       };
74691     } catch (Dali::DaliException e) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74694       };
74695     } catch (...) {
74696       {
74697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74698       };
74699     }
74700   }
74701
74702   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74703   return jresult;
74704 }
74705
74706
74707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
74708   unsigned int jresult ;
74709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74710   unsigned int result;
74711
74712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74713   {
74714     try {
74715       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
74716     } catch (std::out_of_range& e) {
74717       {
74718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74719       };
74720     } catch (std::exception& e) {
74721       {
74722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74723       };
74724     } catch (Dali::DaliException e) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74727       };
74728     } catch (...) {
74729       {
74730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74731       };
74732     }
74733   }
74734
74735   jresult = result;
74736   return jresult;
74737 }
74738
74739
74740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
74741   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74742   Dali::Toolkit::ItemLayout *arg2 = 0 ;
74743
74744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74745   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
74746   if (!arg2) {
74747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
74748     return ;
74749   }
74750   {
74751     try {
74752       (arg1)->AddLayout(*arg2);
74753     } catch (std::out_of_range& e) {
74754       {
74755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74756       };
74757     } catch (std::exception& e) {
74758       {
74759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74760       };
74761     } catch (Dali::DaliException e) {
74762       {
74763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74764       };
74765     } catch (...) {
74766       {
74767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74768       };
74769     }
74770   }
74771
74772 }
74773
74774
74775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
74776   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74777   unsigned int arg2 ;
74778
74779   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74780   arg2 = (unsigned int)jarg2;
74781   {
74782     try {
74783       (arg1)->RemoveLayout(arg2);
74784     } catch (std::out_of_range& e) {
74785       {
74786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74787       };
74788     } catch (std::exception& e) {
74789       {
74790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74791       };
74792     } catch (Dali::DaliException e) {
74793       {
74794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74795       };
74796     } catch (...) {
74797       {
74798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74799       };
74800     }
74801   }
74802
74803 }
74804
74805
74806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
74807   void * jresult ;
74808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74809   unsigned int arg2 ;
74810   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74811
74812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74813   arg2 = (unsigned int)jarg2;
74814   {
74815     try {
74816       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
74817     } catch (std::out_of_range& e) {
74818       {
74819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74820       };
74821     } catch (std::exception& e) {
74822       {
74823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74824       };
74825     } catch (Dali::DaliException e) {
74826       {
74827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74828       };
74829     } catch (...) {
74830       {
74831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74832       };
74833     }
74834   }
74835
74836   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74837   return jresult;
74838 }
74839
74840
74841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
74842   void * jresult ;
74843   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74844   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74845
74846   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74847   {
74848     try {
74849       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
74850     } catch (std::out_of_range& e) {
74851       {
74852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74853       };
74854     } catch (std::exception& e) {
74855       {
74856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74857       };
74858     } catch (Dali::DaliException e) {
74859       {
74860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74861       };
74862     } catch (...) {
74863       {
74864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74865       };
74866     }
74867   }
74868
74869   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74870   return jresult;
74871 }
74872
74873
74874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
74875   float jresult ;
74876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74877   Dali::Toolkit::ItemId arg2 ;
74878   float result;
74879
74880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74881   arg2 = (Dali::Toolkit::ItemId)jarg2;
74882   {
74883     try {
74884       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
74885     } catch (std::out_of_range& e) {
74886       {
74887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74888       };
74889     } catch (std::exception& e) {
74890       {
74891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74892       };
74893     } catch (Dali::DaliException e) {
74894       {
74895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74896       };
74897     } catch (...) {
74898       {
74899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74900       };
74901     }
74902   }
74903
74904   jresult = result;
74905   return jresult;
74906 }
74907
74908
74909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
74910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74911   unsigned int arg2 ;
74912   Dali::Vector3 arg3 ;
74913   float arg4 ;
74914   Dali::Vector3 *argp3 ;
74915
74916   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74917   arg2 = (unsigned int)jarg2;
74918   argp3 = (Dali::Vector3 *)jarg3;
74919   if (!argp3) {
74920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74921     return ;
74922   }
74923   arg3 = *argp3;
74924   arg4 = (float)jarg4;
74925   {
74926     try {
74927       (arg1)->ActivateLayout(arg2,arg3,arg4);
74928     } catch (std::out_of_range& e) {
74929       {
74930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74931       };
74932     } catch (std::exception& e) {
74933       {
74934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74935       };
74936     } catch (Dali::DaliException e) {
74937       {
74938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74939       };
74940     } catch (...) {
74941       {
74942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74943       };
74944     }
74945   }
74946
74947 }
74948
74949
74950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
74951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74952
74953   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74954   {
74955     try {
74956       (arg1)->DeactivateCurrentLayout();
74957     } catch (std::out_of_range& e) {
74958       {
74959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74960       };
74961     } catch (std::exception& e) {
74962       {
74963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74964       };
74965     } catch (Dali::DaliException e) {
74966       {
74967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74968       };
74969     } catch (...) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74972       };
74973     }
74974   }
74975
74976 }
74977
74978
74979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
74980   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74981   float arg2 ;
74982
74983   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74984   arg2 = (float)jarg2;
74985   {
74986     try {
74987       (arg1)->SetMinimumSwipeSpeed(arg2);
74988     } catch (std::out_of_range& e) {
74989       {
74990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74991       };
74992     } catch (std::exception& e) {
74993       {
74994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74995       };
74996     } catch (Dali::DaliException e) {
74997       {
74998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74999       };
75000     } catch (...) {
75001       {
75002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75003       };
75004     }
75005   }
75006
75007 }
75008
75009
75010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75011   float jresult ;
75012   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75013   float result;
75014
75015   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75016   {
75017     try {
75018       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75019     } catch (std::out_of_range& e) {
75020       {
75021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75022       };
75023     } catch (std::exception& e) {
75024       {
75025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75026       };
75027     } catch (Dali::DaliException e) {
75028       {
75029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75030       };
75031     } catch (...) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75034       };
75035     }
75036   }
75037
75038   jresult = result;
75039   return jresult;
75040 }
75041
75042
75043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75044   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75045   float arg2 ;
75046
75047   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75048   arg2 = (float)jarg2;
75049   {
75050     try {
75051       (arg1)->SetMinimumSwipeDistance(arg2);
75052     } catch (std::out_of_range& e) {
75053       {
75054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75055       };
75056     } catch (std::exception& e) {
75057       {
75058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75059       };
75060     } catch (Dali::DaliException e) {
75061       {
75062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75063       };
75064     } catch (...) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75067       };
75068     }
75069   }
75070
75071 }
75072
75073
75074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75075   float jresult ;
75076   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75077   float result;
75078
75079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75080   {
75081     try {
75082       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75083     } catch (std::out_of_range& e) {
75084       {
75085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75086       };
75087     } catch (std::exception& e) {
75088       {
75089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75090       };
75091     } catch (Dali::DaliException e) {
75092       {
75093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75094       };
75095     } catch (...) {
75096       {
75097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75098       };
75099     }
75100   }
75101
75102   jresult = result;
75103   return jresult;
75104 }
75105
75106
75107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75108   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75109   float arg2 ;
75110
75111   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75112   arg2 = (float)jarg2;
75113   {
75114     try {
75115       (arg1)->SetWheelScrollDistanceStep(arg2);
75116     } catch (std::out_of_range& e) {
75117       {
75118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75119       };
75120     } catch (std::exception& e) {
75121       {
75122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75123       };
75124     } catch (Dali::DaliException e) {
75125       {
75126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75127       };
75128     } catch (...) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75131       };
75132     }
75133   }
75134
75135 }
75136
75137
75138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75139   float jresult ;
75140   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75141   float result;
75142
75143   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75144   {
75145     try {
75146       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75147     } catch (std::out_of_range& e) {
75148       {
75149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75150       };
75151     } catch (std::exception& e) {
75152       {
75153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75154       };
75155     } catch (Dali::DaliException e) {
75156       {
75157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75158       };
75159     } catch (...) {
75160       {
75161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75162       };
75163     }
75164   }
75165
75166   jresult = result;
75167   return jresult;
75168 }
75169
75170
75171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75172   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75173   bool arg2 ;
75174
75175   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75176   arg2 = jarg2 ? true : false;
75177   {
75178     try {
75179       (arg1)->SetAnchoring(arg2);
75180     } catch (std::out_of_range& e) {
75181       {
75182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75183       };
75184     } catch (std::exception& e) {
75185       {
75186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75187       };
75188     } catch (Dali::DaliException e) {
75189       {
75190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75191       };
75192     } catch (...) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75195       };
75196     }
75197   }
75198
75199 }
75200
75201 //// ========================= end of part 3 =============================
75202
75203 //// ========================== start part 4 ===============================
75204
75205
75206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75207   unsigned int jresult ;
75208   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75209   bool result;
75210
75211   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75212   {
75213     try {
75214       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75215     } catch (std::out_of_range& e) {
75216       {
75217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75218       };
75219     } catch (std::exception& e) {
75220       {
75221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (Dali::DaliException e) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233
75234   jresult = result;
75235   return jresult;
75236 }
75237
75238
75239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75240   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75241   float arg2 ;
75242
75243   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75244   arg2 = (float)jarg2;
75245   {
75246     try {
75247       (arg1)->SetAnchoringDuration(arg2);
75248     } catch (std::out_of_range& e) {
75249       {
75250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75251       };
75252     } catch (std::exception& e) {
75253       {
75254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75255       };
75256     } catch (Dali::DaliException e) {
75257       {
75258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75259       };
75260     } catch (...) {
75261       {
75262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75263       };
75264     }
75265   }
75266
75267 }
75268
75269
75270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75271   float jresult ;
75272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75273   float result;
75274
75275   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75276   {
75277     try {
75278       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75279     } catch (std::out_of_range& e) {
75280       {
75281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75282       };
75283     } catch (std::exception& e) {
75284       {
75285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75286       };
75287     } catch (Dali::DaliException e) {
75288       {
75289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75290       };
75291     } catch (...) {
75292       {
75293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75294       };
75295     }
75296   }
75297
75298   jresult = result;
75299   return jresult;
75300 }
75301
75302
75303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75305   Dali::Toolkit::ItemId arg2 ;
75306   float arg3 ;
75307
75308   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75309   arg2 = (Dali::Toolkit::ItemId)jarg2;
75310   arg3 = (float)jarg3;
75311   {
75312     try {
75313       (arg1)->ScrollToItem(arg2,arg3);
75314     } catch (std::out_of_range& e) {
75315       {
75316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75317       };
75318     } catch (std::exception& e) {
75319       {
75320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75321       };
75322     } catch (Dali::DaliException e) {
75323       {
75324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75325       };
75326     } catch (...) {
75327       {
75328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75329       };
75330     }
75331   }
75332
75333 }
75334
75335
75336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75337   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75338   float arg2 ;
75339
75340   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75341   arg2 = (float)jarg2;
75342   {
75343     try {
75344       (arg1)->SetRefreshInterval(arg2);
75345     } catch (std::out_of_range& e) {
75346       {
75347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75348       };
75349     } catch (std::exception& e) {
75350       {
75351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75352       };
75353     } catch (Dali::DaliException e) {
75354       {
75355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75356       };
75357     } catch (...) {
75358       {
75359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75360       };
75361     }
75362   }
75363
75364 }
75365
75366
75367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75368   float jresult ;
75369   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75370   float result;
75371
75372   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75373   {
75374     try {
75375       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75376     } catch (std::out_of_range& e) {
75377       {
75378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75379       };
75380     } catch (std::exception& e) {
75381       {
75382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75383       };
75384     } catch (Dali::DaliException e) {
75385       {
75386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75387       };
75388     } catch (...) {
75389       {
75390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75391       };
75392     }
75393   }
75394
75395   jresult = result;
75396   return jresult;
75397 }
75398
75399
75400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75401   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75402
75403   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75404   {
75405     try {
75406       (arg1)->Refresh();
75407     } catch (std::out_of_range& e) {
75408       {
75409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75410       };
75411     } catch (std::exception& e) {
75412       {
75413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75414       };
75415     } catch (Dali::DaliException e) {
75416       {
75417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75418       };
75419     } catch (...) {
75420       {
75421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75422       };
75423     }
75424   }
75425
75426 }
75427
75428
75429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75430   void * jresult ;
75431   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75432   Dali::Toolkit::ItemId arg2 ;
75433   Dali::Actor result;
75434
75435   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75436   arg2 = (Dali::Toolkit::ItemId)jarg2;
75437   {
75438     try {
75439       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75440     } catch (std::out_of_range& e) {
75441       {
75442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75443       };
75444     } catch (std::exception& e) {
75445       {
75446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75447       };
75448     } catch (Dali::DaliException e) {
75449       {
75450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75451       };
75452     } catch (...) {
75453       {
75454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75455       };
75456     }
75457   }
75458
75459   jresult = new Dali::Actor((const Dali::Actor &)result);
75460   return jresult;
75461 }
75462
75463
75464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75465   unsigned int jresult ;
75466   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75467   Dali::Actor arg2 ;
75468   Dali::Actor *argp2 ;
75469   Dali::Toolkit::ItemId result;
75470
75471   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75472   argp2 = (Dali::Actor *)jarg2;
75473   if (!argp2) {
75474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75475     return 0;
75476   }
75477   arg2 = *argp2;
75478   {
75479     try {
75480       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75481     } catch (std::out_of_range& e) {
75482       {
75483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75484       };
75485     } catch (std::exception& e) {
75486       {
75487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (Dali::DaliException e) {
75490       {
75491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75496       };
75497     }
75498   }
75499
75500   jresult = result;
75501   return jresult;
75502 }
75503
75504
75505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75506   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75507   Dali::Toolkit::Item arg2 ;
75508   float arg3 ;
75509   Dali::Toolkit::Item *argp2 ;
75510
75511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75512   argp2 = (Dali::Toolkit::Item *)jarg2;
75513   if (!argp2) {
75514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75515     return ;
75516   }
75517   arg2 = *argp2;
75518   arg3 = (float)jarg3;
75519   {
75520     try {
75521       (arg1)->InsertItem(arg2,arg3);
75522     } catch (std::out_of_range& e) {
75523       {
75524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75525       };
75526     } catch (std::exception& e) {
75527       {
75528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75529       };
75530     } catch (Dali::DaliException e) {
75531       {
75532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75533       };
75534     } catch (...) {
75535       {
75536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75537       };
75538     }
75539   }
75540
75541 }
75542
75543
75544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75545   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75546   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75547   float arg3 ;
75548
75549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75550   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75551   if (!arg2) {
75552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75553     return ;
75554   }
75555   arg3 = (float)jarg3;
75556   {
75557     try {
75558       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75559     } catch (std::out_of_range& e) {
75560       {
75561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75562       };
75563     } catch (std::exception& e) {
75564       {
75565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75566       };
75567     } catch (Dali::DaliException e) {
75568       {
75569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75570       };
75571     } catch (...) {
75572       {
75573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75574       };
75575     }
75576   }
75577
75578 }
75579
75580
75581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75583   Dali::Toolkit::ItemId arg2 ;
75584   float arg3 ;
75585
75586   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75587   arg2 = (Dali::Toolkit::ItemId)jarg2;
75588   arg3 = (float)jarg3;
75589   {
75590     try {
75591       (arg1)->RemoveItem(arg2,arg3);
75592     } catch (std::out_of_range& e) {
75593       {
75594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (std::exception& e) {
75597       {
75598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75599       };
75600     } catch (Dali::DaliException e) {
75601       {
75602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75603       };
75604     } catch (...) {
75605       {
75606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75607       };
75608     }
75609   }
75610
75611 }
75612
75613
75614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75615   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75616   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75617   float arg3 ;
75618
75619   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75620   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75621   if (!arg2) {
75622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75623     return ;
75624   }
75625   arg3 = (float)jarg3;
75626   {
75627     try {
75628       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75629     } catch (std::out_of_range& e) {
75630       {
75631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75632       };
75633     } catch (std::exception& e) {
75634       {
75635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75636       };
75637     } catch (Dali::DaliException e) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75640       };
75641     } catch (...) {
75642       {
75643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75644       };
75645     }
75646   }
75647
75648 }
75649
75650
75651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75653   Dali::Toolkit::Item arg2 ;
75654   float arg3 ;
75655   Dali::Toolkit::Item *argp2 ;
75656
75657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75658   argp2 = (Dali::Toolkit::Item *)jarg2;
75659   if (!argp2) {
75660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75661     return ;
75662   }
75663   arg2 = *argp2;
75664   arg3 = (float)jarg3;
75665   {
75666     try {
75667       (arg1)->ReplaceItem(arg2,arg3);
75668     } catch (std::out_of_range& e) {
75669       {
75670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75671       };
75672     } catch (std::exception& e) {
75673       {
75674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75675       };
75676     } catch (Dali::DaliException e) {
75677       {
75678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75679       };
75680     } catch (...) {
75681       {
75682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75683       };
75684     }
75685   }
75686
75687 }
75688
75689
75690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75692   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75693   float arg3 ;
75694
75695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75696   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75697   if (!arg2) {
75698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75699     return ;
75700   }
75701   arg3 = (float)jarg3;
75702   {
75703     try {
75704       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75705     } catch (std::out_of_range& e) {
75706       {
75707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75708       };
75709     } catch (std::exception& e) {
75710       {
75711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75712       };
75713     } catch (Dali::DaliException e) {
75714       {
75715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75716       };
75717     } catch (...) {
75718       {
75719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75720       };
75721     }
75722   }
75723
75724 }
75725
75726
75727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
75728   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75729   Dali::Vector3 *arg2 = 0 ;
75730
75731   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75732   arg2 = (Dali::Vector3 *)jarg2;
75733   if (!arg2) {
75734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75735     return ;
75736   }
75737   {
75738     try {
75739       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
75740     } catch (std::out_of_range& e) {
75741       {
75742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75743       };
75744     } catch (std::exception& e) {
75745       {
75746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75747       };
75748     } catch (Dali::DaliException e) {
75749       {
75750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75751       };
75752     } catch (...) {
75753       {
75754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75755       };
75756     }
75757   }
75758
75759 }
75760
75761
75762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
75763   void * jresult ;
75764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75765   Dali::Vector3 result;
75766
75767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75768   {
75769     try {
75770       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
75771     } catch (std::out_of_range& e) {
75772       {
75773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75774       };
75775     } catch (std::exception& e) {
75776       {
75777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75778       };
75779     } catch (Dali::DaliException e) {
75780       {
75781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75782       };
75783     } catch (...) {
75784       {
75785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75786       };
75787     }
75788   }
75789
75790   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75791   return jresult;
75792 }
75793
75794
75795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
75796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75797   Dali::Vector3 *arg2 = 0 ;
75798
75799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75800   arg2 = (Dali::Vector3 *)jarg2;
75801   if (!arg2) {
75802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75803     return ;
75804   }
75805   {
75806     try {
75807       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
75808     } catch (std::out_of_range& e) {
75809       {
75810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75811       };
75812     } catch (std::exception& e) {
75813       {
75814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75815       };
75816     } catch (Dali::DaliException e) {
75817       {
75818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75819       };
75820     } catch (...) {
75821       {
75822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75823       };
75824     }
75825   }
75826
75827 }
75828
75829
75830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
75831   void * jresult ;
75832   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75833   Dali::Vector3 result;
75834
75835   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75836   {
75837     try {
75838       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
75839     } catch (std::out_of_range& e) {
75840       {
75841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75842       };
75843     } catch (std::exception& e) {
75844       {
75845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75846       };
75847     } catch (Dali::DaliException e) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75850       };
75851     } catch (...) {
75852       {
75853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75854       };
75855     }
75856   }
75857
75858   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75859   return jresult;
75860 }
75861
75862
75863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
75864   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75865   Dali::Toolkit::ItemRange *arg2 = 0 ;
75866
75867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75868   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75869   if (!arg2) {
75870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
75871     return ;
75872   }
75873   {
75874     try {
75875       (arg1)->GetItemsRange(*arg2);
75876     } catch (std::out_of_range& e) {
75877       {
75878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75879       };
75880     } catch (std::exception& e) {
75881       {
75882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75883       };
75884     } catch (Dali::DaliException e) {
75885       {
75886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75887       };
75888     } catch (...) {
75889       {
75890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75891       };
75892     }
75893   }
75894
75895 }
75896
75897
75898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
75899   void * jresult ;
75900   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75901   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
75902
75903   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75904   {
75905     try {
75906       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
75907     } catch (std::out_of_range& e) {
75908       {
75909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75910       };
75911     } catch (std::exception& e) {
75912       {
75913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75914       };
75915     } catch (Dali::DaliException e) {
75916       {
75917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75918       };
75919     } catch (...) {
75920       {
75921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75922       };
75923     }
75924   }
75925
75926   jresult = (void *)result;
75927   return jresult;
75928 }
75929
75930
75931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
75932   Dali::Vector3 *arg1 = 0 ;
75933   PropertyInputContainer *arg2 = 0 ;
75934
75935   arg1 = (Dali::Vector3 *)jarg1;
75936   if (!arg1) {
75937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75938     return ;
75939   }
75940   arg2 = (PropertyInputContainer *)jarg2;
75941   if (!arg2) {
75942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
75943     return ;
75944   }
75945   {
75946     try {
75947       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
75948     } catch (std::out_of_range& e) {
75949       {
75950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75951       };
75952     } catch (std::exception& e) {
75953       {
75954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75955       };
75956     } catch (Dali::DaliException e) {
75957       {
75958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75959       };
75960     } catch (...) {
75961       {
75962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75963       };
75964     }
75965   }
75966
75967 }
75968
75969
75970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
75971   Dali::Vector3 *arg1 = 0 ;
75972   PropertyInputContainer *arg2 = 0 ;
75973
75974   arg1 = (Dali::Vector3 *)jarg1;
75975   if (!arg1) {
75976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75977     return ;
75978   }
75979   arg2 = (PropertyInputContainer *)jarg2;
75980   if (!arg2) {
75981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
75982     return ;
75983   }
75984   {
75985     try {
75986       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
75987     } catch (std::out_of_range& e) {
75988       {
75989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75990       };
75991     } catch (std::exception& e) {
75992       {
75993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75994       };
75995     } catch (Dali::DaliException e) {
75996       {
75997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75998       };
75999     } catch (...) {
76000       {
76001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76002       };
76003     }
76004   }
76005
76006 }
76007
76008
76009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76010   void * jresult ;
76011   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76012
76013   {
76014     try {
76015       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76016     } catch (std::out_of_range& e) {
76017       {
76018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76019       };
76020     } catch (std::exception& e) {
76021       {
76022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76023       };
76024     } catch (Dali::DaliException e) {
76025       {
76026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76027       };
76028     } catch (...) {
76029       {
76030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76031       };
76032     }
76033   }
76034
76035   jresult = (void *)result;
76036   return jresult;
76037 }
76038
76039
76040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76041   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76042
76043   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76044   {
76045     try {
76046       delete arg1;
76047     } catch (std::out_of_range& e) {
76048       {
76049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76050       };
76051     } catch (std::exception& e) {
76052       {
76053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76054       };
76055     } catch (Dali::DaliException e) {
76056       {
76057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76058       };
76059     } catch (...) {
76060       {
76061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76062       };
76063     }
76064   }
76065
76066 }
76067
76068
76069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76070   void * jresult ;
76071   Dali::Path arg1 ;
76072   Dali::Vector3 *arg2 = 0 ;
76073   Dali::Property::Index arg3 ;
76074   Dali::Vector3 *arg4 = 0 ;
76075   unsigned int arg5 ;
76076   Dali::Path *argp1 ;
76077   Dali::Toolkit::ScrollViewPagePathEffect result;
76078
76079   argp1 = (Dali::Path *)jarg1;
76080   if (!argp1) {
76081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76082     return 0;
76083   }
76084   arg1 = *argp1;
76085   arg2 = (Dali::Vector3 *)jarg2;
76086   if (!arg2) {
76087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76088     return 0;
76089   }
76090   arg3 = (Dali::Property::Index)jarg3;
76091   arg4 = (Dali::Vector3 *)jarg4;
76092   if (!arg4) {
76093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76094     return 0;
76095   }
76096   arg5 = (unsigned int)jarg5;
76097   {
76098     try {
76099       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76100     } catch (std::out_of_range& e) {
76101       {
76102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76103       };
76104     } catch (std::exception& e) {
76105       {
76106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76107       };
76108     } catch (Dali::DaliException e) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76111       };
76112     } catch (...) {
76113       {
76114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76115       };
76116     }
76117   }
76118
76119   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76120   return jresult;
76121 }
76122
76123
76124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76125   void * jresult ;
76126   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76127
76128   {
76129     try {
76130       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76131     } catch (std::out_of_range& e) {
76132       {
76133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (std::exception& e) {
76136       {
76137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76138       };
76139     } catch (Dali::DaliException e) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76142       };
76143     } catch (...) {
76144       {
76145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76146       };
76147     }
76148   }
76149
76150   jresult = (void *)result;
76151   return jresult;
76152 }
76153
76154
76155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76156   void * jresult ;
76157   Dali::BaseHandle arg1 ;
76158   Dali::BaseHandle *argp1 ;
76159   Dali::Toolkit::ScrollViewPagePathEffect result;
76160
76161   argp1 = (Dali::BaseHandle *)jarg1;
76162   if (!argp1) {
76163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76164     return 0;
76165   }
76166   arg1 = *argp1;
76167   {
76168     try {
76169       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76170     } catch (std::out_of_range& e) {
76171       {
76172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76173       };
76174     } catch (std::exception& e) {
76175       {
76176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76177       };
76178     } catch (Dali::DaliException e) {
76179       {
76180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76181       };
76182     } catch (...) {
76183       {
76184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76185       };
76186     }
76187   }
76188
76189   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76190   return jresult;
76191 }
76192
76193
76194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76195   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76196   Dali::Actor arg2 ;
76197   unsigned int arg3 ;
76198   Dali::Actor *argp2 ;
76199
76200   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76201   argp2 = (Dali::Actor *)jarg2;
76202   if (!argp2) {
76203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76204     return ;
76205   }
76206   arg2 = *argp2;
76207   arg3 = (unsigned int)jarg3;
76208   {
76209     try {
76210       (arg1)->ApplyToPage(arg2,arg3);
76211     } catch (std::out_of_range& e) {
76212       {
76213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76214       };
76215     } catch (std::exception& e) {
76216       {
76217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76218       };
76219     } catch (Dali::DaliException e) {
76220       {
76221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76222       };
76223     } catch (...) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76226       };
76227     }
76228   }
76229
76230 }
76231
76232
76233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76234   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76235
76236   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76237   {
76238     try {
76239       delete arg1;
76240     } catch (std::out_of_range& e) {
76241       {
76242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76243       };
76244     } catch (std::exception& e) {
76245       {
76246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76247       };
76248     } catch (Dali::DaliException e) {
76249       {
76250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76251       };
76252     } catch (...) {
76253       {
76254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76255       };
76256     }
76257   }
76258
76259 }
76260
76261
76262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76263   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76264   Dali::Toolkit::ClampState arg2 ;
76265
76266   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76267   arg2 = (Dali::Toolkit::ClampState)jarg2;
76268   if (arg1) (arg1)->x = arg2;
76269 }
76270
76271
76272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76273   int jresult ;
76274   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76275   Dali::Toolkit::ClampState result;
76276
76277   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76278   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76279   jresult = (int)result;
76280   return jresult;
76281 }
76282
76283
76284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76285   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76286   Dali::Toolkit::ClampState arg2 ;
76287
76288   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76289   arg2 = (Dali::Toolkit::ClampState)jarg2;
76290   if (arg1) (arg1)->y = arg2;
76291 }
76292
76293
76294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76295   int jresult ;
76296   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76297   Dali::Toolkit::ClampState result;
76298
76299   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76300   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76301   jresult = (int)result;
76302   return jresult;
76303 }
76304
76305
76306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76307   void * jresult ;
76308   Dali::Toolkit::ClampState2D *result = 0 ;
76309
76310   {
76311     try {
76312       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76313     } catch (std::out_of_range& e) {
76314       {
76315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76316       };
76317     } catch (std::exception& e) {
76318       {
76319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76320       };
76321     } catch (Dali::DaliException e) {
76322       {
76323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76324       };
76325     } catch (...) {
76326       {
76327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76328       };
76329     }
76330   }
76331
76332   jresult = (void *)result;
76333   return jresult;
76334 }
76335
76336
76337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76338   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76339
76340   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76341   {
76342     try {
76343       delete arg1;
76344     } catch (std::out_of_range& e) {
76345       {
76346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76347       };
76348     } catch (std::exception& e) {
76349       {
76350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76351       };
76352     } catch (Dali::DaliException e) {
76353       {
76354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76355       };
76356     } catch (...) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76359       };
76360     }
76361   }
76362
76363 }
76364
76365
76366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76367   void * jresult ;
76368   float arg1 ;
76369   float arg2 ;
76370   bool arg3 ;
76371   Dali::Toolkit::RulerDomain *result = 0 ;
76372
76373   arg1 = (float)jarg1;
76374   arg2 = (float)jarg2;
76375   arg3 = jarg3 ? true : false;
76376   {
76377     try {
76378       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76379     } catch (std::out_of_range& e) {
76380       {
76381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76382       };
76383     } catch (std::exception& e) {
76384       {
76385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (Dali::DaliException e) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76390       };
76391     } catch (...) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76394       };
76395     }
76396   }
76397
76398   jresult = (void *)result;
76399   return jresult;
76400 }
76401
76402
76403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76404   void * jresult ;
76405   float arg1 ;
76406   float arg2 ;
76407   Dali::Toolkit::RulerDomain *result = 0 ;
76408
76409   arg1 = (float)jarg1;
76410   arg2 = (float)jarg2;
76411   {
76412     try {
76413       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76414     } catch (std::out_of_range& e) {
76415       {
76416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76417       };
76418     } catch (std::exception& e) {
76419       {
76420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76421       };
76422     } catch (Dali::DaliException e) {
76423       {
76424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76425       };
76426     } catch (...) {
76427       {
76428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76429       };
76430     }
76431   }
76432
76433   jresult = (void *)result;
76434   return jresult;
76435 }
76436
76437
76438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76439   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76440   float arg2 ;
76441
76442   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76443   arg2 = (float)jarg2;
76444   if (arg1) (arg1)->min = arg2;
76445 }
76446
76447
76448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76449   float jresult ;
76450   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76451   float result;
76452
76453   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76454   result = (float) ((arg1)->min);
76455   jresult = result;
76456   return jresult;
76457 }
76458
76459
76460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76461   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76462   float arg2 ;
76463
76464   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76465   arg2 = (float)jarg2;
76466   if (arg1) (arg1)->max = arg2;
76467 }
76468
76469
76470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76471   float jresult ;
76472   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76473   float result;
76474
76475   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76476   result = (float) ((arg1)->max);
76477   jresult = result;
76478   return jresult;
76479 }
76480
76481
76482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76483   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76484   bool arg2 ;
76485
76486   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76487   arg2 = jarg2 ? true : false;
76488   if (arg1) (arg1)->enabled = arg2;
76489 }
76490
76491
76492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76493   unsigned int jresult ;
76494   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76495   bool result;
76496
76497   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76498   result = (bool) ((arg1)->enabled);
76499   jresult = result;
76500   return jresult;
76501 }
76502
76503
76504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76505   float jresult ;
76506   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76507   float arg2 ;
76508   float arg3 ;
76509   float arg4 ;
76510   float result;
76511
76512   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76513   arg2 = (float)jarg2;
76514   arg3 = (float)jarg3;
76515   arg4 = (float)jarg4;
76516   {
76517     try {
76518       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76519     } catch (std::out_of_range& e) {
76520       {
76521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76522       };
76523     } catch (std::exception& e) {
76524       {
76525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76526       };
76527     } catch (Dali::DaliException e) {
76528       {
76529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76530       };
76531     } catch (...) {
76532       {
76533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76534       };
76535     }
76536   }
76537
76538   jresult = result;
76539   return jresult;
76540 }
76541
76542
76543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76544   float jresult ;
76545   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76546   float arg2 ;
76547   float arg3 ;
76548   float result;
76549
76550   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76551   arg2 = (float)jarg2;
76552   arg3 = (float)jarg3;
76553   {
76554     try {
76555       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76556     } catch (std::out_of_range& e) {
76557       {
76558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76559       };
76560     } catch (std::exception& e) {
76561       {
76562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76563       };
76564     } catch (Dali::DaliException e) {
76565       {
76566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76567       };
76568     } catch (...) {
76569       {
76570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76571       };
76572     }
76573   }
76574
76575   jresult = result;
76576   return jresult;
76577 }
76578
76579
76580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76581   float jresult ;
76582   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76583   float arg2 ;
76584   float result;
76585
76586   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76587   arg2 = (float)jarg2;
76588   {
76589     try {
76590       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76591     } catch (std::out_of_range& e) {
76592       {
76593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76594       };
76595     } catch (std::exception& e) {
76596       {
76597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76598       };
76599     } catch (Dali::DaliException e) {
76600       {
76601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76602       };
76603     } catch (...) {
76604       {
76605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76606       };
76607     }
76608   }
76609
76610   jresult = result;
76611   return jresult;
76612 }
76613
76614
76615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76616   float jresult ;
76617   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76618   float arg2 ;
76619   float arg3 ;
76620   float arg4 ;
76621   Dali::Toolkit::ClampState *arg5 = 0 ;
76622   float result;
76623
76624   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76625   arg2 = (float)jarg2;
76626   arg3 = (float)jarg3;
76627   arg4 = (float)jarg4;
76628   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76629   if (!arg5) {
76630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76631     return 0;
76632   }
76633   {
76634     try {
76635       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76636     } catch (std::out_of_range& e) {
76637       {
76638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76639       };
76640     } catch (std::exception& e) {
76641       {
76642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76643       };
76644     } catch (Dali::DaliException e) {
76645       {
76646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76647       };
76648     } catch (...) {
76649       {
76650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76651       };
76652     }
76653   }
76654
76655   jresult = result;
76656   return jresult;
76657 }
76658
76659
76660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76661   float jresult ;
76662   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76663   float result;
76664
76665   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76666   {
76667     try {
76668       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76669     } catch (std::out_of_range& e) {
76670       {
76671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76672       };
76673     } catch (std::exception& e) {
76674       {
76675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76676       };
76677     } catch (Dali::DaliException e) {
76678       {
76679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76680       };
76681     } catch (...) {
76682       {
76683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76684       };
76685     }
76686   }
76687
76688   jresult = result;
76689   return jresult;
76690 }
76691
76692
76693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76694   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76695
76696   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76697   {
76698     try {
76699       delete arg1;
76700     } catch (std::out_of_range& e) {
76701       {
76702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76703       };
76704     } catch (std::exception& e) {
76705       {
76706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76707       };
76708     } catch (Dali::DaliException e) {
76709       {
76710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76711       };
76712     } catch (...) {
76713       {
76714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76715       };
76716     }
76717   }
76718
76719 }
76720
76721
76722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
76723   float jresult ;
76724   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76725   float arg2 ;
76726   float arg3 ;
76727   float result;
76728
76729   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76730   arg2 = (float)jarg2;
76731   arg3 = (float)jarg3;
76732   {
76733     try {
76734       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
76735     } catch (std::out_of_range& e) {
76736       {
76737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76738       };
76739     } catch (std::exception& e) {
76740       {
76741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76742       };
76743     } catch (Dali::DaliException e) {
76744       {
76745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76746       };
76747     } catch (...) {
76748       {
76749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76750       };
76751     }
76752   }
76753
76754   jresult = result;
76755   return jresult;
76756 }
76757
76758
76759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
76760   float jresult ;
76761   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76762   float arg2 ;
76763   float result;
76764
76765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76766   arg2 = (float)jarg2;
76767   {
76768     try {
76769       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
76770     } catch (std::out_of_range& e) {
76771       {
76772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76773       };
76774     } catch (std::exception& e) {
76775       {
76776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76777       };
76778     } catch (Dali::DaliException e) {
76779       {
76780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76781       };
76782     } catch (...) {
76783       {
76784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76785       };
76786     }
76787   }
76788
76789   jresult = result;
76790   return jresult;
76791 }
76792
76793
76794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
76795   float jresult ;
76796   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76797   unsigned int arg2 ;
76798   unsigned int *arg3 = 0 ;
76799   bool arg4 ;
76800   float result;
76801
76802   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76803   arg2 = (unsigned int)jarg2;
76804   arg3 = (unsigned int *)jarg3;
76805   arg4 = jarg4 ? true : false;
76806   {
76807     try {
76808       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
76809     } catch (std::out_of_range& e) {
76810       {
76811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76812       };
76813     } catch (std::exception& e) {
76814       {
76815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76816       };
76817     } catch (Dali::DaliException e) {
76818       {
76819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76820       };
76821     } catch (...) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76824       };
76825     }
76826   }
76827
76828   jresult = result;
76829   return jresult;
76830 }
76831
76832
76833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
76834   unsigned int jresult ;
76835   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76836   float arg2 ;
76837   bool arg3 ;
76838   unsigned int result;
76839
76840   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76841   arg2 = (float)jarg2;
76842   arg3 = jarg3 ? true : false;
76843   {
76844     try {
76845       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
76846     } catch (std::out_of_range& e) {
76847       {
76848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76849       };
76850     } catch (std::exception& e) {
76851       {
76852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76853       };
76854     } catch (Dali::DaliException e) {
76855       {
76856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76857       };
76858     } catch (...) {
76859       {
76860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76861       };
76862     }
76863   }
76864
76865   jresult = result;
76866   return jresult;
76867 }
76868
76869
76870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
76871   unsigned int jresult ;
76872   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76873   unsigned int result;
76874
76875   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76876   {
76877     try {
76878       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
76879     } catch (std::out_of_range& e) {
76880       {
76881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (std::exception& e) {
76884       {
76885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (Dali::DaliException e) {
76888       {
76889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76890       };
76891     } catch (...) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76894       };
76895     }
76896   }
76897
76898   jresult = result;
76899   return jresult;
76900 }
76901
76902
76903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
76904   int jresult ;
76905   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76906   Dali::Toolkit::Ruler::RulerType result;
76907
76908   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76909   {
76910     try {
76911       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
76912     } catch (std::out_of_range& e) {
76913       {
76914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76915       };
76916     } catch (std::exception& e) {
76917       {
76918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76919       };
76920     } catch (Dali::DaliException e) {
76921       {
76922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76923       };
76924     } catch (...) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76927       };
76928     }
76929   }
76930
76931   jresult = (int)result;
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
76937   unsigned int jresult ;
76938   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76939   bool result;
76940
76941   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76942   {
76943     try {
76944       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
76945     } catch (std::out_of_range& e) {
76946       {
76947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76948       };
76949     } catch (std::exception& e) {
76950       {
76951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76952       };
76953     } catch (Dali::DaliException e) {
76954       {
76955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76956       };
76957     } catch (...) {
76958       {
76959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76960       };
76961     }
76962   }
76963
76964   jresult = result;
76965   return jresult;
76966 }
76967
76968
76969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
76970   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76971
76972   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76973   {
76974     try {
76975       (arg1)->Enable();
76976     } catch (std::out_of_range& e) {
76977       {
76978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76979       };
76980     } catch (std::exception& e) {
76981       {
76982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76983       };
76984     } catch (Dali::DaliException e) {
76985       {
76986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76987       };
76988     } catch (...) {
76989       {
76990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76991       };
76992     }
76993   }
76994
76995 }
76996
76997
76998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
76999   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77000
77001   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77002   {
77003     try {
77004       (arg1)->Disable();
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 void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77028   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77029   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77030   Dali::Toolkit::RulerDomain *argp2 ;
77031
77032   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77033   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77034   if (!argp2) {
77035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77036     return ;
77037   }
77038   arg2 = *argp2;
77039   {
77040     try {
77041       (arg1)->SetDomain(arg2);
77042     } catch (std::out_of_range& e) {
77043       {
77044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77045       };
77046     } catch (std::exception& e) {
77047       {
77048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77049       };
77050     } catch (Dali::DaliException e) {
77051       {
77052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77053       };
77054     } catch (...) {
77055       {
77056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77057       };
77058     }
77059   }
77060
77061 }
77062
77063
77064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77065   void * jresult ;
77066   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77067   Dali::Toolkit::RulerDomain *result = 0 ;
77068
77069   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77070   {
77071     try {
77072       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77073     } catch (std::out_of_range& e) {
77074       {
77075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77076       };
77077     } catch (std::exception& e) {
77078       {
77079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77080       };
77081     } catch (Dali::DaliException e) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77084       };
77085     } catch (...) {
77086       {
77087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77088       };
77089     }
77090   }
77091
77092   jresult = (void *)result;
77093   return jresult;
77094 }
77095
77096
77097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77098   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77099
77100   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77101   {
77102     try {
77103       (arg1)->DisableDomain();
77104     } catch (std::out_of_range& e) {
77105       {
77106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77107       };
77108     } catch (std::exception& e) {
77109       {
77110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77111       };
77112     } catch (Dali::DaliException e) {
77113       {
77114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77115       };
77116     } catch (...) {
77117       {
77118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77119       };
77120     }
77121   }
77122
77123 }
77124
77125
77126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77127   float jresult ;
77128   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77129   float arg2 ;
77130   float arg3 ;
77131   float arg4 ;
77132   float result;
77133
77134   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77135   arg2 = (float)jarg2;
77136   arg3 = (float)jarg3;
77137   arg4 = (float)jarg4;
77138   {
77139     try {
77140       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77141     } catch (std::out_of_range& e) {
77142       {
77143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77144       };
77145     } catch (std::exception& e) {
77146       {
77147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77148       };
77149     } catch (Dali::DaliException e) {
77150       {
77151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77152       };
77153     } catch (...) {
77154       {
77155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77156       };
77157     }
77158   }
77159
77160   jresult = result;
77161   return jresult;
77162 }
77163
77164
77165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77166   float jresult ;
77167   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77168   float arg2 ;
77169   float arg3 ;
77170   float result;
77171
77172   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77173   arg2 = (float)jarg2;
77174   arg3 = (float)jarg3;
77175   {
77176     try {
77177       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77178     } catch (std::out_of_range& e) {
77179       {
77180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77181       };
77182     } catch (std::exception& e) {
77183       {
77184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77185       };
77186     } catch (Dali::DaliException e) {
77187       {
77188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77189       };
77190     } catch (...) {
77191       {
77192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77193       };
77194     }
77195   }
77196
77197   jresult = result;
77198   return jresult;
77199 }
77200
77201
77202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77203   float jresult ;
77204   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77205   float arg2 ;
77206   float result;
77207
77208   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77209   arg2 = (float)jarg2;
77210   {
77211     try {
77212       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77213     } catch (std::out_of_range& e) {
77214       {
77215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77216       };
77217     } catch (std::exception& e) {
77218       {
77219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77220       };
77221     } catch (Dali::DaliException e) {
77222       {
77223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77224       };
77225     } catch (...) {
77226       {
77227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77228       };
77229     }
77230   }
77231
77232   jresult = result;
77233   return jresult;
77234 }
77235
77236
77237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77238   float jresult ;
77239   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77240   float arg2 ;
77241   float arg3 ;
77242   float arg4 ;
77243   Dali::Toolkit::ClampState *arg5 = 0 ;
77244   float result;
77245
77246   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77247   arg2 = (float)jarg2;
77248   arg3 = (float)jarg3;
77249   arg4 = (float)jarg4;
77250   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77251   if (!arg5) {
77252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77253     return 0;
77254   }
77255   {
77256     try {
77257       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77258     } catch (std::out_of_range& e) {
77259       {
77260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77261       };
77262     } catch (std::exception& e) {
77263       {
77264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77265       };
77266     } catch (Dali::DaliException e) {
77267       {
77268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77269       };
77270     } catch (...) {
77271       {
77272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77273       };
77274     }
77275   }
77276
77277   jresult = result;
77278   return jresult;
77279 }
77280
77281
77282 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77283   float jresult ;
77284   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77285   float arg2 ;
77286   float arg3 ;
77287   float arg4 ;
77288   float arg5 ;
77289   float result;
77290
77291   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77292   arg2 = (float)jarg2;
77293   arg3 = (float)jarg3;
77294   arg4 = (float)jarg4;
77295   arg5 = (float)jarg5;
77296   {
77297     try {
77298       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77299     } catch (std::out_of_range& e) {
77300       {
77301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77302       };
77303     } catch (std::exception& e) {
77304       {
77305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77306       };
77307     } catch (Dali::DaliException e) {
77308       {
77309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77310       };
77311     } catch (...) {
77312       {
77313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77314       };
77315     }
77316   }
77317
77318   jresult = result;
77319   return jresult;
77320 }
77321
77322
77323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77324   float jresult ;
77325   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77326   float arg2 ;
77327   float arg3 ;
77328   float arg4 ;
77329   float result;
77330
77331   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77332   arg2 = (float)jarg2;
77333   arg3 = (float)jarg3;
77334   arg4 = (float)jarg4;
77335   {
77336     try {
77337       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77338     } catch (std::out_of_range& e) {
77339       {
77340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77341       };
77342     } catch (std::exception& e) {
77343       {
77344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77345       };
77346     } catch (Dali::DaliException e) {
77347       {
77348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77349       };
77350     } catch (...) {
77351       {
77352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77353       };
77354     }
77355   }
77356
77357   jresult = result;
77358   return jresult;
77359 }
77360
77361
77362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77363   float jresult ;
77364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77365   float arg2 ;
77366   float arg3 ;
77367   float result;
77368
77369   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77370   arg2 = (float)jarg2;
77371   arg3 = (float)jarg3;
77372   {
77373     try {
77374       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77382       };
77383     } catch (Dali::DaliException e) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77386       };
77387     } catch (...) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77390       };
77391     }
77392   }
77393
77394   jresult = result;
77395   return jresult;
77396 }
77397
77398
77399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77400   float jresult ;
77401   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77402   float arg2 ;
77403   float result;
77404
77405   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77406   arg2 = (float)jarg2;
77407   {
77408     try {
77409       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77410     } catch (std::out_of_range& e) {
77411       {
77412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77413       };
77414     } catch (std::exception& e) {
77415       {
77416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77417       };
77418     } catch (Dali::DaliException e) {
77419       {
77420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77421       };
77422     } catch (...) {
77423       {
77424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77425       };
77426     }
77427   }
77428
77429   jresult = result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77435   float jresult ;
77436   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77437   float arg2 ;
77438   float arg3 ;
77439   float arg4 ;
77440   float arg5 ;
77441   Dali::Toolkit::ClampState *arg6 = 0 ;
77442   float result;
77443
77444   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77445   arg2 = (float)jarg2;
77446   arg3 = (float)jarg3;
77447   arg4 = (float)jarg4;
77448   arg5 = (float)jarg5;
77449   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77450   if (!arg6) {
77451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77452     return 0;
77453   }
77454   {
77455     try {
77456       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77457     } catch (std::out_of_range& e) {
77458       {
77459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77460       };
77461     } catch (std::exception& e) {
77462       {
77463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77464       };
77465     } catch (Dali::DaliException e) {
77466       {
77467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77468       };
77469     } catch (...) {
77470       {
77471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77472       };
77473     }
77474   }
77475
77476   jresult = result;
77477   return jresult;
77478 }
77479
77480
77481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77482   void * jresult ;
77483   Dali::Toolkit::DefaultRuler *result = 0 ;
77484
77485   {
77486     try {
77487       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77488     } catch (std::out_of_range& e) {
77489       {
77490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77491       };
77492     } catch (std::exception& e) {
77493       {
77494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77495       };
77496     } catch (Dali::DaliException e) {
77497       {
77498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77499       };
77500     } catch (...) {
77501       {
77502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77503       };
77504     }
77505   }
77506
77507   jresult = (void *)result;
77508   return jresult;
77509 }
77510
77511
77512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77513   float jresult ;
77514   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77515   float arg2 ;
77516   float arg3 ;
77517   float result;
77518
77519   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77520   arg2 = (float)jarg2;
77521   arg3 = (float)jarg3;
77522   {
77523     try {
77524       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77525     } catch (std::out_of_range& e) {
77526       {
77527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77528       };
77529     } catch (std::exception& e) {
77530       {
77531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77532       };
77533     } catch (Dali::DaliException e) {
77534       {
77535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77536       };
77537     } catch (...) {
77538       {
77539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77540       };
77541     }
77542   }
77543
77544   jresult = result;
77545   return jresult;
77546 }
77547
77548
77549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77550   float jresult ;
77551   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77552   unsigned int arg2 ;
77553   unsigned int *arg3 = 0 ;
77554   bool arg4 ;
77555   float result;
77556
77557   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77558   arg2 = (unsigned int)jarg2;
77559   arg3 = (unsigned int *)jarg3;
77560   arg4 = jarg4 ? true : false;
77561   {
77562     try {
77563       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77571       };
77572     } catch (Dali::DaliException e) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77579       };
77580     }
77581   }
77582
77583   jresult = result;
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77589   unsigned int jresult ;
77590   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77591   float arg2 ;
77592   bool arg3 ;
77593   unsigned int result;
77594
77595   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77596   arg2 = (float)jarg2;
77597   arg3 = jarg3 ? true : false;
77598   {
77599     try {
77600       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77601     } catch (std::out_of_range& e) {
77602       {
77603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77604       };
77605     } catch (std::exception& e) {
77606       {
77607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77608       };
77609     } catch (Dali::DaliException e) {
77610       {
77611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77612       };
77613     } catch (...) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77616       };
77617     }
77618   }
77619
77620   jresult = result;
77621   return jresult;
77622 }
77623
77624
77625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77626   unsigned int jresult ;
77627   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77628   unsigned int result;
77629
77630   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77631   {
77632     try {
77633       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77634     } catch (std::out_of_range& e) {
77635       {
77636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77637       };
77638     } catch (std::exception& e) {
77639       {
77640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77641       };
77642     } catch (Dali::DaliException e) {
77643       {
77644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77645       };
77646     } catch (...) {
77647       {
77648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77649       };
77650     }
77651   }
77652
77653   jresult = result;
77654   return jresult;
77655 }
77656
77657
77658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77659   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77660
77661   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77662   {
77663     try {
77664       delete arg1;
77665     } catch (std::out_of_range& e) {
77666       {
77667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77668       };
77669     } catch (std::exception& e) {
77670       {
77671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77672       };
77673     } catch (Dali::DaliException e) {
77674       {
77675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77676       };
77677     } catch (...) {
77678       {
77679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77680       };
77681     }
77682   }
77683
77684 }
77685
77686
77687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77688   void * jresult ;
77689   float arg1 ;
77690   Dali::Toolkit::FixedRuler *result = 0 ;
77691
77692   arg1 = (float)jarg1;
77693   {
77694     try {
77695       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77696     } catch (std::out_of_range& e) {
77697       {
77698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77699       };
77700     } catch (std::exception& e) {
77701       {
77702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77703       };
77704     } catch (Dali::DaliException e) {
77705       {
77706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77707       };
77708     } catch (...) {
77709       {
77710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77711       };
77712     }
77713   }
77714
77715   jresult = (void *)result;
77716   return jresult;
77717 }
77718
77719
77720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
77721   void * jresult ;
77722   Dali::Toolkit::FixedRuler *result = 0 ;
77723
77724   {
77725     try {
77726       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
77727     } catch (std::out_of_range& e) {
77728       {
77729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77730       };
77731     } catch (std::exception& e) {
77732       {
77733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77734       };
77735     } catch (Dali::DaliException e) {
77736       {
77737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77738       };
77739     } catch (...) {
77740       {
77741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77742       };
77743     }
77744   }
77745
77746   jresult = (void *)result;
77747   return jresult;
77748 }
77749
77750
77751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77752   float jresult ;
77753   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77754   float arg2 ;
77755   float arg3 ;
77756   float result;
77757
77758   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77759   arg2 = (float)jarg2;
77760   arg3 = (float)jarg3;
77761   {
77762     try {
77763       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
77764     } catch (std::out_of_range& e) {
77765       {
77766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77767       };
77768     } catch (std::exception& e) {
77769       {
77770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77771       };
77772     } catch (Dali::DaliException e) {
77773       {
77774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77775       };
77776     } catch (...) {
77777       {
77778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77779       };
77780     }
77781   }
77782
77783   jresult = result;
77784   return jresult;
77785 }
77786
77787
77788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77789   float jresult ;
77790   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77791   unsigned int arg2 ;
77792   unsigned int *arg3 = 0 ;
77793   bool arg4 ;
77794   float result;
77795
77796   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77797   arg2 = (unsigned int)jarg2;
77798   arg3 = (unsigned int *)jarg3;
77799   arg4 = jarg4 ? true : false;
77800   {
77801     try {
77802       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77803     } catch (std::out_of_range& e) {
77804       {
77805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77806       };
77807     } catch (std::exception& e) {
77808       {
77809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77810       };
77811     } catch (Dali::DaliException e) {
77812       {
77813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77814       };
77815     } catch (...) {
77816       {
77817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77818       };
77819     }
77820   }
77821
77822   jresult = result;
77823   return jresult;
77824 }
77825
77826
77827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77828   unsigned int jresult ;
77829   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77830   float arg2 ;
77831   bool arg3 ;
77832   unsigned int result;
77833
77834   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77835   arg2 = (float)jarg2;
77836   arg3 = jarg3 ? true : false;
77837   {
77838     try {
77839       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77840     } catch (std::out_of_range& e) {
77841       {
77842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77843       };
77844     } catch (std::exception& e) {
77845       {
77846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77847       };
77848     } catch (Dali::DaliException e) {
77849       {
77850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77851       };
77852     } catch (...) {
77853       {
77854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77855       };
77856     }
77857   }
77858
77859   jresult = result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
77865   unsigned int jresult ;
77866   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77867   unsigned int result;
77868
77869   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77870   {
77871     try {
77872       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
77873     } catch (std::out_of_range& e) {
77874       {
77875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77876       };
77877     } catch (std::exception& e) {
77878       {
77879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77880       };
77881     } catch (Dali::DaliException e) {
77882       {
77883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77884       };
77885     } catch (...) {
77886       {
77887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77888       };
77889     }
77890   }
77891
77892   jresult = result;
77893   return jresult;
77894 }
77895
77896
77897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
77898   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77899
77900   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77901   {
77902     try {
77903       delete arg1;
77904     } catch (std::out_of_range& e) {
77905       {
77906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77907       };
77908     } catch (std::exception& e) {
77909       {
77910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77911       };
77912     } catch (Dali::DaliException e) {
77913       {
77914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77915       };
77916     } catch (...) {
77917       {
77918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77919       };
77920     }
77921   }
77922
77923 }
77924
77925
77926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
77927   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77928   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
77929
77930   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77931   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
77932   if (arg1) (arg1)->scale = *arg2;
77933 }
77934
77935
77936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
77937   void * jresult ;
77938   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77939   Dali::Toolkit::ClampState2D *result = 0 ;
77940
77941   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77942   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
77943   jresult = (void *)result;
77944   return jresult;
77945 }
77946
77947
77948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
77949   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77950   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
77951
77952   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77953   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
77954   if (arg1) (arg1)->position = *arg2;
77955 }
77956
77957
77958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
77959   void * jresult ;
77960   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77961   Dali::Toolkit::ClampState2D *result = 0 ;
77962
77963   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77964   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
77965   jresult = (void *)result;
77966   return jresult;
77967 }
77968
77969
77970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
77971   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77972   Dali::Toolkit::ClampState arg2 ;
77973
77974   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77975   arg2 = (Dali::Toolkit::ClampState)jarg2;
77976   if (arg1) (arg1)->rotation = arg2;
77977 }
77978
77979
77980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
77981   int jresult ;
77982   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
77983   Dali::Toolkit::ClampState result;
77984
77985   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
77986   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
77987   jresult = (int)result;
77988   return jresult;
77989 }
77990
77991
77992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
77993   void * jresult ;
77994   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
77995
77996   {
77997     try {
77998       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
77999     } catch (std::out_of_range& e) {
78000       {
78001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78002       };
78003     } catch (std::exception& e) {
78004       {
78005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (Dali::DaliException e) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78010       };
78011     } catch (...) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78014       };
78015     }
78016   }
78017
78018   jresult = (void *)result;
78019   return jresult;
78020 }
78021
78022
78023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78024   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78025
78026   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78027   {
78028     try {
78029       delete arg1;
78030     } catch (std::out_of_range& e) {
78031       {
78032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78033       };
78034     } catch (std::exception& e) {
78035       {
78036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78037       };
78038     } catch (Dali::DaliException e) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78041       };
78042     } catch (...) {
78043       {
78044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78045       };
78046     }
78047   }
78048
78049 }
78050
78051
78052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78053   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78054   Dali::Toolkit::SnapType arg2 ;
78055
78056   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78057   arg2 = (Dali::Toolkit::SnapType)jarg2;
78058   if (arg1) (arg1)->type = arg2;
78059 }
78060
78061
78062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78063   int jresult ;
78064   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78065   Dali::Toolkit::SnapType result;
78066
78067   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78068   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78069   jresult = (int)result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78075   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78076   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78077
78078   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78079   arg2 = (Dali::Vector2 *)jarg2;
78080   if (arg1) (arg1)->position = *arg2;
78081 }
78082
78083
78084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78085   void * jresult ;
78086   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78087   Dali::Vector2 *result = 0 ;
78088
78089   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78090   result = (Dali::Vector2 *)& ((arg1)->position);
78091   jresult = (void *)result;
78092   return jresult;
78093 }
78094
78095
78096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78097   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78098   float arg2 ;
78099
78100   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78101   arg2 = (float)jarg2;
78102   if (arg1) (arg1)->duration = arg2;
78103 }
78104
78105
78106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78107   float jresult ;
78108   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78109   float result;
78110
78111   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78112   result = (float) ((arg1)->duration);
78113   jresult = result;
78114   return jresult;
78115 }
78116
78117
78118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78119   void * jresult ;
78120   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78121
78122   {
78123     try {
78124       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78125     } catch (std::out_of_range& e) {
78126       {
78127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78128       };
78129     } catch (std::exception& e) {
78130       {
78131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78132       };
78133     } catch (Dali::DaliException e) {
78134       {
78135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78136       };
78137     } catch (...) {
78138       {
78139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78140       };
78141     }
78142   }
78143
78144   jresult = (void *)result;
78145   return jresult;
78146 }
78147
78148
78149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78150   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78151
78152   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78153   {
78154     try {
78155       delete arg1;
78156     } catch (std::out_of_range& e) {
78157       {
78158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78159       };
78160     } catch (std::exception& e) {
78161       {
78162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78163       };
78164     } catch (Dali::DaliException e) {
78165       {
78166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78167       };
78168     } catch (...) {
78169       {
78170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78171       };
78172     }
78173   }
78174
78175 }
78176
78177
78178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78179   int jresult ;
78180   int result;
78181
78182   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78183   jresult = (int)result;
78184   return jresult;
78185 }
78186
78187
78188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78189   int jresult ;
78190   int result;
78191
78192   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78193   jresult = (int)result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78199   int jresult ;
78200   int result;
78201
78202   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78203   jresult = (int)result;
78204   return jresult;
78205 }
78206
78207
78208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78209   int jresult ;
78210   int result;
78211
78212   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78213   jresult = (int)result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78219   int jresult ;
78220   int result;
78221
78222   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78223   jresult = (int)result;
78224   return jresult;
78225 }
78226
78227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78228   int jresult ;
78229   int result;
78230
78231   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78232   jresult = (int)result;
78233   return jresult;
78234 }
78235
78236
78237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78238   int jresult ;
78239   int result;
78240
78241   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78242   jresult = (int)result;
78243   return jresult;
78244 }
78245
78246
78247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78248   int jresult ;
78249   int result;
78250
78251   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78252   jresult = (int)result;
78253   return jresult;
78254 }
78255
78256
78257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78258   int jresult ;
78259   int result;
78260
78261   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78262   jresult = (int)result;
78263   return jresult;
78264 }
78265
78266
78267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78268   int jresult ;
78269   int result;
78270
78271   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78272   jresult = (int)result;
78273   return jresult;
78274 }
78275
78276
78277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78278   int jresult ;
78279   int result;
78280
78281   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78282   jresult = (int)result;
78283   return jresult;
78284 }
78285
78286
78287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78288   int jresult ;
78289   int result;
78290
78291   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78292   jresult = (int)result;
78293   return jresult;
78294 }
78295
78296
78297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78298   int jresult ;
78299   int result;
78300
78301   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78302   jresult = (int)result;
78303   return jresult;
78304 }
78305
78306
78307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78308   int jresult ;
78309   int result;
78310
78311   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78312   jresult = (int)result;
78313   return jresult;
78314 }
78315
78316
78317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78318   int jresult ;
78319   int result;
78320
78321   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78322   jresult = (int)result;
78323   return jresult;
78324 }
78325
78326
78327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78328   int jresult ;
78329   int result;
78330
78331   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78332   jresult = (int)result;
78333   return jresult;
78334 }
78335
78336
78337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78338   int jresult ;
78339   int result;
78340
78341   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78342   jresult = (int)result;
78343   return jresult;
78344 }
78345
78346
78347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78348   int jresult ;
78349   int result;
78350
78351   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78352   jresult = (int)result;
78353   return jresult;
78354 }
78355
78356
78357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78358   int jresult ;
78359   int result;
78360
78361   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78362   jresult = (int)result;
78363   return jresult;
78364 }
78365
78366
78367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78368   int jresult ;
78369   int result;
78370
78371   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78372   jresult = (int)result;
78373   return jresult;
78374 }
78375
78376
78377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78378   int jresult ;
78379   int result;
78380
78381   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78382   jresult = (int)result;
78383   return jresult;
78384 }
78385
78386
78387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78388   int jresult ;
78389   int result;
78390
78391   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78392   jresult = (int)result;
78393   return jresult;
78394 }
78395
78396
78397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78398   int jresult ;
78399   int result;
78400
78401   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78402   jresult = (int)result;
78403   return jresult;
78404 }
78405
78406
78407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78408   int jresult ;
78409   int result;
78410
78411   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78412   jresult = (int)result;
78413   return jresult;
78414 }
78415
78416
78417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78418   int jresult ;
78419   int result;
78420
78421   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78422   jresult = (int)result;
78423   return jresult;
78424 }
78425
78426
78427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78428   int jresult ;
78429   int result;
78430
78431   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78432   jresult = (int)result;
78433   return jresult;
78434 }
78435
78436
78437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78438   void * jresult ;
78439   Dali::Toolkit::ScrollView::Property *result = 0 ;
78440
78441   {
78442     try {
78443       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78444     } catch (std::out_of_range& e) {
78445       {
78446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78447       };
78448     } catch (std::exception& e) {
78449       {
78450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78451       };
78452     } catch (Dali::DaliException e) {
78453       {
78454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78455       };
78456     } catch (...) {
78457       {
78458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78459       };
78460     }
78461   }
78462
78463   jresult = (void *)result;
78464   return jresult;
78465 }
78466
78467
78468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78469   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78470
78471   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78472   {
78473     try {
78474       delete arg1;
78475     } catch (std::out_of_range& e) {
78476       {
78477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78478       };
78479     } catch (std::exception& e) {
78480       {
78481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78482       };
78483     } catch (Dali::DaliException e) {
78484       {
78485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78486       };
78487     } catch (...) {
78488       {
78489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78490       };
78491     }
78492   }
78493
78494 }
78495
78496
78497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78498   void * jresult ;
78499   Dali::Toolkit::ScrollView *result = 0 ;
78500
78501   {
78502     try {
78503       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78504     } catch (std::out_of_range& e) {
78505       {
78506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78507       };
78508     } catch (std::exception& e) {
78509       {
78510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78511       };
78512     } catch (Dali::DaliException e) {
78513       {
78514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78515       };
78516     } catch (...) {
78517       {
78518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78519       };
78520     }
78521   }
78522
78523   jresult = (void *)result;
78524   return jresult;
78525 }
78526
78527
78528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78529   void * jresult ;
78530   Dali::Toolkit::ScrollView *arg1 = 0 ;
78531   Dali::Toolkit::ScrollView *result = 0 ;
78532
78533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78534   if (!arg1) {
78535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78536     return 0;
78537   }
78538   {
78539     try {
78540       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78541     } catch (std::out_of_range& e) {
78542       {
78543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78544       };
78545     } catch (std::exception& e) {
78546       {
78547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78548       };
78549     } catch (Dali::DaliException e) {
78550       {
78551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78552       };
78553     } catch (...) {
78554       {
78555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78556       };
78557     }
78558   }
78559
78560   jresult = (void *)result;
78561   return jresult;
78562 }
78563
78564
78565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78566   void * jresult ;
78567   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78568   Dali::Toolkit::ScrollView *arg2 = 0 ;
78569   Dali::Toolkit::ScrollView *result = 0 ;
78570
78571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78572   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78573   if (!arg2) {
78574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78575     return 0;
78576   }
78577   {
78578     try {
78579       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78580     } catch (std::out_of_range& e) {
78581       {
78582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78583       };
78584     } catch (std::exception& e) {
78585       {
78586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78587       };
78588     } catch (Dali::DaliException e) {
78589       {
78590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78591       };
78592     } catch (...) {
78593       {
78594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78595       };
78596     }
78597   }
78598
78599   jresult = (void *)result;
78600   return jresult;
78601 }
78602
78603
78604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78606
78607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78608   {
78609     try {
78610       delete arg1;
78611     } catch (std::out_of_range& e) {
78612       {
78613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78614       };
78615     } catch (std::exception& e) {
78616       {
78617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78618       };
78619     } catch (Dali::DaliException e) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78622       };
78623     } catch (...) {
78624       {
78625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78626       };
78627     }
78628   }
78629
78630 }
78631
78632
78633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78634   void * jresult ;
78635   Dali::Toolkit::ScrollView result;
78636
78637   {
78638     try {
78639       result = Dali::Toolkit::ScrollView::New();
78640     } catch (std::out_of_range& e) {
78641       {
78642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78643       };
78644     } catch (std::exception& e) {
78645       {
78646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78647       };
78648     } catch (Dali::DaliException e) {
78649       {
78650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78651       };
78652     } catch (...) {
78653       {
78654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78655       };
78656     }
78657   }
78658
78659   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78660   return jresult;
78661 }
78662
78663
78664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78665   void * jresult ;
78666   Dali::BaseHandle arg1 ;
78667   Dali::BaseHandle *argp1 ;
78668   Dali::Toolkit::ScrollView result;
78669
78670   argp1 = (Dali::BaseHandle *)jarg1;
78671   if (!argp1) {
78672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78673     return 0;
78674   }
78675   arg1 = *argp1;
78676   {
78677     try {
78678       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78679     } catch (std::out_of_range& e) {
78680       {
78681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78682       };
78683     } catch (std::exception& e) {
78684       {
78685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78686       };
78687     } catch (Dali::DaliException e) {
78688       {
78689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78690       };
78691     } catch (...) {
78692       {
78693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78694       };
78695     }
78696   }
78697
78698   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78699   return jresult;
78700 }
78701
78702
78703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
78704   void * jresult ;
78705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78706   Dali::AlphaFunction result;
78707
78708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78709   {
78710     try {
78711       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
78712     } catch (std::out_of_range& e) {
78713       {
78714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78715       };
78716     } catch (std::exception& e) {
78717       {
78718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78719       };
78720     } catch (Dali::DaliException e) {
78721       {
78722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78723       };
78724     } catch (...) {
78725       {
78726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78727       };
78728     }
78729   }
78730
78731   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
78737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78738   Dali::AlphaFunction arg2 ;
78739   Dali::AlphaFunction *argp2 ;
78740
78741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78742   argp2 = (Dali::AlphaFunction *)jarg2;
78743   if (!argp2) {
78744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78745     return ;
78746   }
78747   arg2 = *argp2;
78748   {
78749     try {
78750       (arg1)->SetScrollSnapAlphaFunction(arg2);
78751     } catch (std::out_of_range& e) {
78752       {
78753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78754       };
78755     } catch (std::exception& e) {
78756       {
78757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78758       };
78759     } catch (Dali::DaliException e) {
78760       {
78761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78762       };
78763     } catch (...) {
78764       {
78765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78766       };
78767     }
78768   }
78769
78770 }
78771
78772
78773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
78774   void * jresult ;
78775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78776   Dali::AlphaFunction result;
78777
78778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78779   {
78780     try {
78781       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
78782     } catch (std::out_of_range& e) {
78783       {
78784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78785       };
78786     } catch (std::exception& e) {
78787       {
78788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78789       };
78790     } catch (Dali::DaliException e) {
78791       {
78792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78793       };
78794     } catch (...) {
78795       {
78796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78797       };
78798     }
78799   }
78800
78801   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
78807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78808   Dali::AlphaFunction arg2 ;
78809   Dali::AlphaFunction *argp2 ;
78810
78811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78812   argp2 = (Dali::AlphaFunction *)jarg2;
78813   if (!argp2) {
78814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78815     return ;
78816   }
78817   arg2 = *argp2;
78818   {
78819     try {
78820       (arg1)->SetScrollFlickAlphaFunction(arg2);
78821     } catch (std::out_of_range& e) {
78822       {
78823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78824       };
78825     } catch (std::exception& e) {
78826       {
78827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78828       };
78829     } catch (Dali::DaliException e) {
78830       {
78831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78832       };
78833     } catch (...) {
78834       {
78835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78836       };
78837     }
78838   }
78839
78840 }
78841
78842
78843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
78844   float jresult ;
78845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78846   float result;
78847
78848   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78849   {
78850     try {
78851       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (Dali::DaliException e) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78863       };
78864     } catch (...) {
78865       {
78866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78867       };
78868     }
78869   }
78870
78871   jresult = result;
78872   return jresult;
78873 }
78874
78875
78876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
78877   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78878   float arg2 ;
78879
78880   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78881   arg2 = (float)jarg2;
78882   {
78883     try {
78884       (arg1)->SetScrollSnapDuration(arg2);
78885     } catch (std::out_of_range& e) {
78886       {
78887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78888       };
78889     } catch (std::exception& e) {
78890       {
78891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78892       };
78893     } catch (Dali::DaliException e) {
78894       {
78895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78896       };
78897     } catch (...) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78900       };
78901     }
78902   }
78903
78904 }
78905
78906
78907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
78908   float jresult ;
78909   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78910   float result;
78911
78912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78913   {
78914     try {
78915       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
78916     } catch (std::out_of_range& e) {
78917       {
78918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78919       };
78920     } catch (std::exception& e) {
78921       {
78922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78923       };
78924     } catch (Dali::DaliException e) {
78925       {
78926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78927       };
78928     } catch (...) {
78929       {
78930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78931       };
78932     }
78933   }
78934
78935   jresult = result;
78936   return jresult;
78937 }
78938
78939
78940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
78941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78942   float arg2 ;
78943
78944   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78945   arg2 = (float)jarg2;
78946   {
78947     try {
78948       (arg1)->SetScrollFlickDuration(arg2);
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78956       };
78957     } catch (Dali::DaliException e) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78960       };
78961     } catch (...) {
78962       {
78963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78964       };
78965     }
78966   }
78967
78968 }
78969
78970
78971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
78972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78973   Dali::Toolkit::RulerPtr arg2 ;
78974   Dali::Toolkit::RulerPtr *argp2 ;
78975
78976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78977   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
78978   if (!argp2) {
78979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
78980     return ;
78981   }
78982   arg2 = *argp2;
78983   {
78984     try {
78985       (arg1)->SetRulerX(arg2);
78986     } catch (std::out_of_range& e) {
78987       {
78988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78989       };
78990     } catch (std::exception& e) {
78991       {
78992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78993       };
78994     } catch (Dali::DaliException e) {
78995       {
78996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78997       };
78998     } catch (...) {
78999       {
79000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79001       };
79002     }
79003   }
79004
79005 }
79006
79007
79008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79010   Dali::Toolkit::RulerPtr arg2 ;
79011   Dali::Toolkit::RulerPtr *argp2 ;
79012
79013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79014   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79015   if (!argp2) {
79016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79017     return ;
79018   }
79019   arg2 = *argp2;
79020   {
79021     try {
79022       (arg1)->SetRulerY(arg2);
79023     } catch (std::out_of_range& e) {
79024       {
79025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79026       };
79027     } catch (std::exception& e) {
79028       {
79029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79030       };
79031     } catch (Dali::DaliException e) {
79032       {
79033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79034       };
79035     } catch (...) {
79036       {
79037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79038       };
79039     }
79040   }
79041
79042 }
79043
79044
79045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79046   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79047   bool arg2 ;
79048
79049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79050   arg2 = jarg2 ? true : false;
79051   {
79052     try {
79053       (arg1)->SetScrollSensitive(arg2);
79054     } catch (std::out_of_range& e) {
79055       {
79056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79057       };
79058     } catch (std::exception& e) {
79059       {
79060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79061       };
79062     } catch (Dali::DaliException e) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79065       };
79066     } catch (...) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79069       };
79070     }
79071   }
79072
79073 }
79074
79075
79076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79078   float arg2 ;
79079   float arg3 ;
79080
79081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79082   arg2 = (float)jarg2;
79083   arg3 = (float)jarg3;
79084   {
79085     try {
79086       (arg1)->SetMaxOvershoot(arg2,arg3);
79087     } catch (std::out_of_range& e) {
79088       {
79089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79090       };
79091     } catch (std::exception& e) {
79092       {
79093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79094       };
79095     } catch (Dali::DaliException e) {
79096       {
79097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79098       };
79099     } catch (...) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79102       };
79103     }
79104   }
79105
79106 }
79107
79108
79109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79111   Dali::AlphaFunction arg2 ;
79112   Dali::AlphaFunction *argp2 ;
79113
79114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79115   argp2 = (Dali::AlphaFunction *)jarg2;
79116   if (!argp2) {
79117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79118     return ;
79119   }
79120   arg2 = *argp2;
79121   {
79122     try {
79123       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79124     } catch (std::out_of_range& e) {
79125       {
79126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79127       };
79128     } catch (std::exception& e) {
79129       {
79130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79131       };
79132     } catch (Dali::DaliException e) {
79133       {
79134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79135       };
79136     } catch (...) {
79137       {
79138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79139       };
79140     }
79141   }
79142
79143 }
79144
79145
79146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79147   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79148   float arg2 ;
79149
79150   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79151   arg2 = (float)jarg2;
79152   {
79153     try {
79154       (arg1)->SetSnapOvershootDuration(arg2);
79155     } catch (std::out_of_range& e) {
79156       {
79157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79158       };
79159     } catch (std::exception& e) {
79160       {
79161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79162       };
79163     } catch (Dali::DaliException e) {
79164       {
79165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79166       };
79167     } catch (...) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79170       };
79171     }
79172   }
79173
79174 }
79175
79176
79177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79179   bool arg2 ;
79180
79181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79182   arg2 = jarg2 ? true : false;
79183   {
79184     try {
79185       (arg1)->SetActorAutoSnap(arg2);
79186     } catch (std::out_of_range& e) {
79187       {
79188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79189       };
79190     } catch (std::exception& e) {
79191       {
79192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79193       };
79194     } catch (Dali::DaliException e) {
79195       {
79196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79197       };
79198     } catch (...) {
79199       {
79200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79201       };
79202     }
79203   }
79204
79205 }
79206
79207
79208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79210   bool arg2 ;
79211
79212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79213   arg2 = jarg2 ? true : false;
79214   {
79215     try {
79216       (arg1)->SetWrapMode(arg2);
79217     } catch (std::out_of_range& e) {
79218       {
79219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79220       };
79221     } catch (std::exception& e) {
79222       {
79223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79224       };
79225     } catch (Dali::DaliException e) {
79226       {
79227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79228       };
79229     } catch (...) {
79230       {
79231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79232       };
79233     }
79234   }
79235
79236 }
79237
79238
79239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79240   int jresult ;
79241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79242   int result;
79243
79244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79245   {
79246     try {
79247       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79248     } catch (std::out_of_range& e) {
79249       {
79250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79251       };
79252     } catch (std::exception& e) {
79253       {
79254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79255       };
79256     } catch (Dali::DaliException e) {
79257       {
79258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79259       };
79260     } catch (...) {
79261       {
79262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79263       };
79264     }
79265   }
79266
79267   jresult = result;
79268   return jresult;
79269 }
79270
79271
79272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79273   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79274   int arg2 ;
79275
79276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79277   arg2 = (int)jarg2;
79278   {
79279     try {
79280       (arg1)->SetScrollUpdateDistance(arg2);
79281     } catch (std::out_of_range& e) {
79282       {
79283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79284       };
79285     } catch (std::exception& e) {
79286       {
79287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79288       };
79289     } catch (Dali::DaliException e) {
79290       {
79291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79292       };
79293     } catch (...) {
79294       {
79295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79296       };
79297     }
79298   }
79299
79300 }
79301
79302
79303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79304   unsigned int jresult ;
79305   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79306   bool result;
79307
79308   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79309   {
79310     try {
79311       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79312     } catch (std::out_of_range& e) {
79313       {
79314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79315       };
79316     } catch (std::exception& e) {
79317       {
79318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79319       };
79320     } catch (Dali::DaliException e) {
79321       {
79322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79323       };
79324     } catch (...) {
79325       {
79326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79327       };
79328     }
79329   }
79330
79331   jresult = result;
79332   return jresult;
79333 }
79334
79335
79336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79338   bool arg2 ;
79339
79340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79341   arg2 = jarg2 ? true : false;
79342   {
79343     try {
79344       (arg1)->SetAxisAutoLock(arg2);
79345     } catch (std::out_of_range& e) {
79346       {
79347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79348       };
79349     } catch (std::exception& e) {
79350       {
79351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79352       };
79353     } catch (Dali::DaliException e) {
79354       {
79355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79356       };
79357     } catch (...) {
79358       {
79359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79360       };
79361     }
79362   }
79363
79364 }
79365
79366
79367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79368   float jresult ;
79369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79370   float result;
79371
79372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79373   {
79374     try {
79375       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79376     } catch (std::out_of_range& e) {
79377       {
79378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79379       };
79380     } catch (std::exception& e) {
79381       {
79382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79383       };
79384     } catch (Dali::DaliException e) {
79385       {
79386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79387       };
79388     } catch (...) {
79389       {
79390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79391       };
79392     }
79393   }
79394
79395   jresult = result;
79396   return jresult;
79397 }
79398
79399
79400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79402   float arg2 ;
79403
79404   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79405   arg2 = (float)jarg2;
79406   {
79407     try {
79408       (arg1)->SetAxisAutoLockGradient(arg2);
79409     } catch (std::out_of_range& e) {
79410       {
79411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79412       };
79413     } catch (std::exception& e) {
79414       {
79415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79416       };
79417     } catch (Dali::DaliException e) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79420       };
79421     } catch (...) {
79422       {
79423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79424       };
79425     }
79426   }
79427
79428 }
79429
79430
79431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79432   float jresult ;
79433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79434   float result;
79435
79436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79437   {
79438     try {
79439       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79440     } catch (std::out_of_range& e) {
79441       {
79442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79443       };
79444     } catch (std::exception& e) {
79445       {
79446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79447       };
79448     } catch (Dali::DaliException e) {
79449       {
79450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79451       };
79452     } catch (...) {
79453       {
79454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79455       };
79456     }
79457   }
79458
79459   jresult = result;
79460   return jresult;
79461 }
79462
79463
79464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79465   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79466   float arg2 ;
79467
79468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79469   arg2 = (float)jarg2;
79470   {
79471     try {
79472       (arg1)->SetFrictionCoefficient(arg2);
79473     } catch (std::out_of_range& e) {
79474       {
79475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79476       };
79477     } catch (std::exception& e) {
79478       {
79479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79480       };
79481     } catch (Dali::DaliException e) {
79482       {
79483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79484       };
79485     } catch (...) {
79486       {
79487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79488       };
79489     }
79490   }
79491
79492 }
79493
79494
79495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79496   float jresult ;
79497   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79498   float result;
79499
79500   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79501   {
79502     try {
79503       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79504     } catch (std::out_of_range& e) {
79505       {
79506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79507       };
79508     } catch (std::exception& e) {
79509       {
79510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79511       };
79512     } catch (Dali::DaliException e) {
79513       {
79514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79515       };
79516     } catch (...) {
79517       {
79518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79519       };
79520     }
79521   }
79522
79523   jresult = result;
79524   return jresult;
79525 }
79526
79527
79528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79530   float arg2 ;
79531
79532   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79533   arg2 = (float)jarg2;
79534   {
79535     try {
79536       (arg1)->SetFlickSpeedCoefficient(arg2);
79537     } catch (std::out_of_range& e) {
79538       {
79539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79540       };
79541     } catch (std::exception& e) {
79542       {
79543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79544       };
79545     } catch (Dali::DaliException e) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79548       };
79549     } catch (...) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79552       };
79553     }
79554   }
79555
79556 }
79557
79558
79559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79560   void * jresult ;
79561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79562   Dali::Vector2 result;
79563
79564   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79565   {
79566     try {
79567       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79568     } catch (std::out_of_range& e) {
79569       {
79570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79571       };
79572     } catch (std::exception& e) {
79573       {
79574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79575       };
79576     } catch (Dali::DaliException e) {
79577       {
79578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79579       };
79580     } catch (...) {
79581       {
79582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79583       };
79584     }
79585   }
79586
79587   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79588   return jresult;
79589 }
79590
79591
79592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79594   Dali::Vector2 *arg2 = 0 ;
79595
79596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79597   arg2 = (Dali::Vector2 *)jarg2;
79598   if (!arg2) {
79599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79600     return ;
79601   }
79602   {
79603     try {
79604       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79612       };
79613     } catch (Dali::DaliException e) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79616       };
79617     } catch (...) {
79618       {
79619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79620       };
79621     }
79622   }
79623
79624 }
79625
79626
79627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79628   float jresult ;
79629   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79630   float result;
79631
79632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79633   {
79634     try {
79635       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79636     } catch (std::out_of_range& e) {
79637       {
79638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79639       };
79640     } catch (std::exception& e) {
79641       {
79642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79643       };
79644     } catch (Dali::DaliException e) {
79645       {
79646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79647       };
79648     } catch (...) {
79649       {
79650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79651       };
79652     }
79653   }
79654
79655   jresult = result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79662   float arg2 ;
79663
79664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79665   arg2 = (float)jarg2;
79666   {
79667     try {
79668       (arg1)->SetMinimumSpeedForFlick(arg2);
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79676       };
79677     } catch (Dali::DaliException e) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79680       };
79681     } catch (...) {
79682       {
79683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79684       };
79685     }
79686   }
79687
79688 }
79689
79690
79691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79692   float jresult ;
79693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79694   float result;
79695
79696   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79697   {
79698     try {
79699       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
79700     } catch (std::out_of_range& e) {
79701       {
79702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79703       };
79704     } catch (std::exception& e) {
79705       {
79706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79707       };
79708     } catch (Dali::DaliException e) {
79709       {
79710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79711       };
79712     } catch (...) {
79713       {
79714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79715       };
79716     }
79717   }
79718
79719   jresult = result;
79720   return jresult;
79721 }
79722
79723
79724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
79725   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79726   float arg2 ;
79727
79728   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79729   arg2 = (float)jarg2;
79730   {
79731     try {
79732       (arg1)->SetMaxFlickSpeed(arg2);
79733     } catch (std::out_of_range& e) {
79734       {
79735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79736       };
79737     } catch (std::exception& e) {
79738       {
79739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79740       };
79741     } catch (Dali::DaliException e) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79744       };
79745     } catch (...) {
79746       {
79747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79748       };
79749     }
79750   }
79751
79752 }
79753
79754
79755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
79756   void * jresult ;
79757   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79758   Dali::Vector2 result;
79759
79760   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79761   {
79762     try {
79763       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
79764     } catch (std::out_of_range& e) {
79765       {
79766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79767       };
79768     } catch (std::exception& e) {
79769       {
79770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79771       };
79772     } catch (Dali::DaliException e) {
79773       {
79774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79775       };
79776     } catch (...) {
79777       {
79778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79779       };
79780     }
79781   }
79782
79783   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79784   return jresult;
79785 }
79786
79787
79788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
79789   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79790   Dali::Vector2 arg2 ;
79791   Dali::Vector2 *argp2 ;
79792
79793   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79794   argp2 = (Dali::Vector2 *)jarg2;
79795   if (!argp2) {
79796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
79797     return ;
79798   }
79799   arg2 = *argp2;
79800   {
79801     try {
79802       (arg1)->SetWheelScrollDistanceStep(arg2);
79803     } catch (std::out_of_range& e) {
79804       {
79805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79806       };
79807     } catch (std::exception& e) {
79808       {
79809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79810       };
79811     } catch (Dali::DaliException e) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79814       };
79815     } catch (...) {
79816       {
79817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79818       };
79819     }
79820   }
79821
79822 }
79823
79824
79825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
79826   void * jresult ;
79827   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79828   Dali::Vector2 result;
79829
79830   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79831   {
79832     try {
79833       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
79834     } catch (std::out_of_range& e) {
79835       {
79836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79837       };
79838     } catch (std::exception& e) {
79839       {
79840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79841       };
79842     } catch (Dali::DaliException e) {
79843       {
79844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79845       };
79846     } catch (...) {
79847       {
79848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79849       };
79850     }
79851   }
79852
79853   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79854   return jresult;
79855 }
79856
79857
79858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
79859   unsigned int jresult ;
79860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79861   unsigned int result;
79862
79863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79864   {
79865     try {
79866       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
79867     } catch (std::out_of_range& e) {
79868       {
79869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79870       };
79871     } catch (std::exception& e) {
79872       {
79873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79874       };
79875     } catch (Dali::DaliException e) {
79876       {
79877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79878       };
79879     } catch (...) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79882       };
79883     }
79884   }
79885
79886   jresult = result;
79887   return jresult;
79888 }
79889
79890
79891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
79892   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79893   Dali::Vector2 *arg2 = 0 ;
79894
79895   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79896   arg2 = (Dali::Vector2 *)jarg2;
79897   if (!arg2) {
79898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79899     return ;
79900   }
79901   {
79902     try {
79903       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
79904     } catch (std::out_of_range& e) {
79905       {
79906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79907       };
79908     } catch (std::exception& e) {
79909       {
79910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79911       };
79912     } catch (Dali::DaliException e) {
79913       {
79914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79915       };
79916     } catch (...) {
79917       {
79918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79919       };
79920     }
79921   }
79922
79923 }
79924
79925
79926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
79927   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79928   Dali::Vector2 *arg2 = 0 ;
79929   float arg3 ;
79930
79931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79932   arg2 = (Dali::Vector2 *)jarg2;
79933   if (!arg2) {
79934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79935     return ;
79936   }
79937   arg3 = (float)jarg3;
79938   {
79939     try {
79940       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
79941     } catch (std::out_of_range& e) {
79942       {
79943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79944       };
79945     } catch (std::exception& e) {
79946       {
79947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79948       };
79949     } catch (Dali::DaliException e) {
79950       {
79951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79952       };
79953     } catch (...) {
79954       {
79955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79956       };
79957     }
79958   }
79959
79960 }
79961
79962
79963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
79964   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79965   Dali::Vector2 *arg2 = 0 ;
79966   float arg3 ;
79967   Dali::AlphaFunction arg4 ;
79968   Dali::AlphaFunction *argp4 ;
79969
79970   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79971   arg2 = (Dali::Vector2 *)jarg2;
79972   if (!arg2) {
79973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79974     return ;
79975   }
79976   arg3 = (float)jarg3;
79977   argp4 = (Dali::AlphaFunction *)jarg4;
79978   if (!argp4) {
79979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79980     return ;
79981   }
79982   arg4 = *argp4;
79983   {
79984     try {
79985       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
79986     } catch (std::out_of_range& e) {
79987       {
79988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79989       };
79990     } catch (std::exception& e) {
79991       {
79992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79993       };
79994     } catch (Dali::DaliException e) {
79995       {
79996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79997       };
79998     } catch (...) {
79999       {
80000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80001       };
80002     }
80003   }
80004
80005 }
80006
80007
80008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80009   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80010   Dali::Vector2 *arg2 = 0 ;
80011   float arg3 ;
80012   Dali::Toolkit::DirectionBias arg4 ;
80013   Dali::Toolkit::DirectionBias arg5 ;
80014
80015   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80016   arg2 = (Dali::Vector2 *)jarg2;
80017   if (!arg2) {
80018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80019     return ;
80020   }
80021   arg3 = (float)jarg3;
80022   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80023   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80024   {
80025     try {
80026       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80027     } catch (std::out_of_range& e) {
80028       {
80029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80030       };
80031     } catch (std::exception& e) {
80032       {
80033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80034       };
80035     } catch (Dali::DaliException e) {
80036       {
80037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80038       };
80039     } catch (...) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80042       };
80043     }
80044   }
80045
80046 }
80047
80048
80049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80050   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80051   Dali::Vector2 *arg2 = 0 ;
80052   float arg3 ;
80053   Dali::AlphaFunction arg4 ;
80054   Dali::Toolkit::DirectionBias arg5 ;
80055   Dali::Toolkit::DirectionBias arg6 ;
80056   Dali::AlphaFunction *argp4 ;
80057
80058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80059   arg2 = (Dali::Vector2 *)jarg2;
80060   if (!arg2) {
80061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80062     return ;
80063   }
80064   arg3 = (float)jarg3;
80065   argp4 = (Dali::AlphaFunction *)jarg4;
80066   if (!argp4) {
80067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80068     return ;
80069   }
80070   arg4 = *argp4;
80071   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80072   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80073   {
80074     try {
80075       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80076     } catch (std::out_of_range& e) {
80077       {
80078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80079       };
80080     } catch (std::exception& e) {
80081       {
80082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80083       };
80084     } catch (Dali::DaliException e) {
80085       {
80086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80087       };
80088     } catch (...) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80091       };
80092     }
80093   }
80094
80095 }
80096
80097
80098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80099   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80100   unsigned int arg2 ;
80101
80102   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80103   arg2 = (unsigned int)jarg2;
80104   {
80105     try {
80106       (arg1)->ScrollTo(arg2);
80107     } catch (std::out_of_range& e) {
80108       {
80109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80110       };
80111     } catch (std::exception& e) {
80112       {
80113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80114       };
80115     } catch (Dali::DaliException e) {
80116       {
80117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80118       };
80119     } catch (...) {
80120       {
80121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80122       };
80123     }
80124   }
80125
80126 }
80127
80128
80129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80131   unsigned int arg2 ;
80132   float arg3 ;
80133
80134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80135   arg2 = (unsigned int)jarg2;
80136   arg3 = (float)jarg3;
80137   {
80138     try {
80139       (arg1)->ScrollTo(arg2,arg3);
80140     } catch (std::out_of_range& e) {
80141       {
80142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80143       };
80144     } catch (std::exception& e) {
80145       {
80146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80147       };
80148     } catch (Dali::DaliException e) {
80149       {
80150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80151       };
80152     } catch (...) {
80153       {
80154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80155       };
80156     }
80157   }
80158
80159 }
80160
80161
80162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80163   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80164   unsigned int arg2 ;
80165   float arg3 ;
80166   Dali::Toolkit::DirectionBias arg4 ;
80167
80168   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80169   arg2 = (unsigned int)jarg2;
80170   arg3 = (float)jarg3;
80171   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80172   {
80173     try {
80174       (arg1)->ScrollTo(arg2,arg3,arg4);
80175     } catch (std::out_of_range& e) {
80176       {
80177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80178       };
80179     } catch (std::exception& e) {
80180       {
80181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80182       };
80183     } catch (Dali::DaliException e) {
80184       {
80185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80186       };
80187     } catch (...) {
80188       {
80189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80190       };
80191     }
80192   }
80193
80194 }
80195
80196
80197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80198   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80199   Dali::Actor *arg2 = 0 ;
80200
80201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80202   arg2 = (Dali::Actor *)jarg2;
80203   if (!arg2) {
80204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80205     return ;
80206   }
80207   {
80208     try {
80209       (arg1)->ScrollTo(*arg2);
80210     } catch (std::out_of_range& e) {
80211       {
80212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80213       };
80214     } catch (std::exception& e) {
80215       {
80216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80217       };
80218     } catch (Dali::DaliException e) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80221       };
80222     } catch (...) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80225       };
80226     }
80227   }
80228
80229 }
80230
80231
80232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80234   Dali::Actor *arg2 = 0 ;
80235   float arg3 ;
80236
80237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80238   arg2 = (Dali::Actor *)jarg2;
80239   if (!arg2) {
80240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80241     return ;
80242   }
80243   arg3 = (float)jarg3;
80244   {
80245     try {
80246       (arg1)->ScrollTo(*arg2,arg3);
80247     } catch (std::out_of_range& e) {
80248       {
80249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80250       };
80251     } catch (std::exception& e) {
80252       {
80253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80254       };
80255     } catch (Dali::DaliException e) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80258       };
80259     } catch (...) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80262       };
80263     }
80264   }
80265
80266 }
80267
80268
80269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80270   unsigned int jresult ;
80271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80272   bool result;
80273
80274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80275   {
80276     try {
80277       result = (bool)(arg1)->ScrollToSnapPoint();
80278     } catch (std::out_of_range& e) {
80279       {
80280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80281       };
80282     } catch (std::exception& e) {
80283       {
80284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80285       };
80286     } catch (Dali::DaliException e) {
80287       {
80288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80293       };
80294     }
80295   }
80296
80297   jresult = result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80303   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80304   Dali::Constraint arg2 ;
80305   Dali::Constraint *argp2 ;
80306
80307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80308   argp2 = (Dali::Constraint *)jarg2;
80309   if (!argp2) {
80310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80311     return ;
80312   }
80313   arg2 = *argp2;
80314   {
80315     try {
80316       (arg1)->ApplyConstraintToChildren(arg2);
80317     } catch (std::out_of_range& e) {
80318       {
80319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80320       };
80321     } catch (std::exception& e) {
80322       {
80323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80324       };
80325     } catch (Dali::DaliException e) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80328       };
80329     } catch (...) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80332       };
80333     }
80334   }
80335
80336 }
80337
80338
80339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80340   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80341
80342   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80343   {
80344     try {
80345       (arg1)->RemoveConstraintsFromChildren();
80346     } catch (std::out_of_range& e) {
80347       {
80348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80349       };
80350     } catch (std::exception& e) {
80351       {
80352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80353       };
80354     } catch (Dali::DaliException e) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80357       };
80358     } catch (...) {
80359       {
80360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80361       };
80362     }
80363   }
80364
80365 }
80366
80367
80368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80370   Dali::Toolkit::ScrollViewEffect arg2 ;
80371   Dali::Toolkit::ScrollViewEffect *argp2 ;
80372
80373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80374   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80375   if (!argp2) {
80376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80377     return ;
80378   }
80379   arg2 = *argp2;
80380   {
80381     try {
80382       (arg1)->ApplyEffect(arg2);
80383     } catch (std::out_of_range& e) {
80384       {
80385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80386       };
80387     } catch (std::exception& e) {
80388       {
80389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80390       };
80391     } catch (Dali::DaliException e) {
80392       {
80393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80394       };
80395     } catch (...) {
80396       {
80397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80398       };
80399     }
80400   }
80401
80402 }
80403
80404
80405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80406   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80407   Dali::Toolkit::ScrollViewEffect arg2 ;
80408   Dali::Toolkit::ScrollViewEffect *argp2 ;
80409
80410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80411   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80412   if (!argp2) {
80413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80414     return ;
80415   }
80416   arg2 = *argp2;
80417   {
80418     try {
80419       (arg1)->RemoveEffect(arg2);
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80427       };
80428     } catch (Dali::DaliException e) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80431       };
80432     } catch (...) {
80433       {
80434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80435       };
80436     }
80437   }
80438
80439 }
80440
80441
80442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80443   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80444
80445   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80446   {
80447     try {
80448       (arg1)->RemoveAllEffects();
80449     } catch (std::out_of_range& e) {
80450       {
80451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80452       };
80453     } catch (std::exception& e) {
80454       {
80455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80456       };
80457     } catch (Dali::DaliException e) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80460       };
80461     } catch (...) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80464       };
80465     }
80466   }
80467
80468 }
80469
80470
80471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80472   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80473   Dali::Actor arg2 ;
80474   Dali::Actor *argp2 ;
80475
80476   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80477   argp2 = (Dali::Actor *)jarg2;
80478   if (!argp2) {
80479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80480     return ;
80481   }
80482   arg2 = *argp2;
80483   {
80484     try {
80485       (arg1)->BindActor(arg2);
80486     } catch (std::out_of_range& e) {
80487       {
80488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80489       };
80490     } catch (std::exception& e) {
80491       {
80492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80493       };
80494     } catch (Dali::DaliException e) {
80495       {
80496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80497       };
80498     } catch (...) {
80499       {
80500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80501       };
80502     }
80503   }
80504
80505 }
80506
80507
80508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80510   Dali::Actor arg2 ;
80511   Dali::Actor *argp2 ;
80512
80513   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80514   argp2 = (Dali::Actor *)jarg2;
80515   if (!argp2) {
80516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80517     return ;
80518   }
80519   arg2 = *argp2;
80520   {
80521     try {
80522       (arg1)->UnbindActor(arg2);
80523     } catch (std::out_of_range& e) {
80524       {
80525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (std::exception& e) {
80528       {
80529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80530       };
80531     } catch (Dali::DaliException e) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80538       };
80539     }
80540   }
80541
80542 }
80543
80544
80545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80546   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80547   Dali::Radian arg2 ;
80548   Dali::Radian arg3 ;
80549   Dali::Radian *argp2 ;
80550   Dali::Radian *argp3 ;
80551
80552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80553   argp2 = (Dali::Radian *)jarg2;
80554   if (!argp2) {
80555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80556     return ;
80557   }
80558   arg2 = *argp2;
80559   argp3 = (Dali::Radian *)jarg3;
80560   if (!argp3) {
80561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80562     return ;
80563   }
80564   arg3 = *argp3;
80565   {
80566     try {
80567       (arg1)->SetScrollingDirection(arg2,arg3);
80568     } catch (std::out_of_range& e) {
80569       {
80570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80571       };
80572     } catch (std::exception& e) {
80573       {
80574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80575       };
80576     } catch (Dali::DaliException e) {
80577       {
80578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80579       };
80580     } catch (...) {
80581       {
80582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80583       };
80584     }
80585   }
80586
80587 }
80588
80589
80590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80592   Dali::Radian arg2 ;
80593   Dali::Radian *argp2 ;
80594
80595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80596   argp2 = (Dali::Radian *)jarg2;
80597   if (!argp2) {
80598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80599     return ;
80600   }
80601   arg2 = *argp2;
80602   {
80603     try {
80604       (arg1)->SetScrollingDirection(arg2);
80605     } catch (std::out_of_range& e) {
80606       {
80607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80608       };
80609     } catch (std::exception& e) {
80610       {
80611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80612       };
80613     } catch (Dali::DaliException e) {
80614       {
80615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80620       };
80621     }
80622   }
80623
80624 }
80625
80626
80627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80628   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80629   Dali::Radian arg2 ;
80630   Dali::Radian *argp2 ;
80631
80632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80633   argp2 = (Dali::Radian *)jarg2;
80634   if (!argp2) {
80635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80636     return ;
80637   }
80638   arg2 = *argp2;
80639   {
80640     try {
80641       (arg1)->RemoveScrollingDirection(arg2);
80642     } catch (std::out_of_range& e) {
80643       {
80644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80645       };
80646     } catch (std::exception& e) {
80647       {
80648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80649       };
80650     } catch (Dali::DaliException e) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80653       };
80654     } catch (...) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80657       };
80658     }
80659   }
80660
80661 }
80662
80663
80664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80665   void * jresult ;
80666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80667   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80668
80669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80670   {
80671     try {
80672       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80673     } catch (std::out_of_range& e) {
80674       {
80675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80676       };
80677     } catch (std::exception& e) {
80678       {
80679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80680       };
80681     } catch (Dali::DaliException e) {
80682       {
80683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80684       };
80685     } catch (...) {
80686       {
80687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80688       };
80689     }
80690   }
80691
80692   jresult = (void *)result;
80693   return jresult;
80694 }
80695
80696
80697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80698   int jresult ;
80699   int result;
80700
80701   result = (int)Dali::Toolkit::TableView::Property::ROWS;
80702   jresult = (int)result;
80703   return jresult;
80704 }
80705
80706
80707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
80708   int jresult ;
80709   int result;
80710
80711   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
80712   jresult = (int)result;
80713   return jresult;
80714 }
80715
80716
80717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
80718   int jresult ;
80719   int result;
80720
80721   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
80722   jresult = (int)result;
80723   return jresult;
80724 }
80725
80726
80727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
80728   int jresult ;
80729   int result;
80730
80731   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
80732   jresult = (int)result;
80733   return jresult;
80734 }
80735
80736
80737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
80738   int jresult ;
80739   int result;
80740
80741   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
80742   jresult = (int)result;
80743   return jresult;
80744 }
80745
80746
80747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
80748   void * jresult ;
80749   Dali::Toolkit::TableView::Property *result = 0 ;
80750
80751   {
80752     try {
80753       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
80754     } catch (std::out_of_range& e) {
80755       {
80756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80757       };
80758     } catch (std::exception& e) {
80759       {
80760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80761       };
80762     } catch (Dali::DaliException e) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80765       };
80766     } catch (...) {
80767       {
80768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80769       };
80770     }
80771   }
80772
80773   jresult = (void *)result;
80774   return jresult;
80775 }
80776
80777
80778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
80779   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
80780
80781   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
80782   {
80783     try {
80784       delete arg1;
80785     } catch (std::out_of_range& e) {
80786       {
80787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80788       };
80789     } catch (std::exception& e) {
80790       {
80791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80792       };
80793     } catch (Dali::DaliException e) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80796       };
80797     } catch (...) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80800       };
80801     }
80802   }
80803
80804 }
80805
80806
80807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
80808   int jresult ;
80809   int result;
80810
80811   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
80812   jresult = (int)result;
80813   return jresult;
80814 }
80815
80816
80817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
80818   int jresult ;
80819   int result;
80820
80821   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
80822   jresult = (int)result;
80823   return jresult;
80824 }
80825
80826
80827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
80828   int jresult ;
80829   int result;
80830
80831   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
80832   jresult = (int)result;
80833   return jresult;
80834 }
80835
80836
80837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
80838   int jresult ;
80839   int result;
80840
80841   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
80842   jresult = (int)result;
80843   return jresult;
80844 }
80845
80846
80847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
80848   int jresult ;
80849   int result;
80850
80851   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
80852   jresult = (int)result;
80853   return jresult;
80854 }
80855
80856
80857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
80858   void * jresult ;
80859   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
80860
80861   {
80862     try {
80863       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
80864     } catch (std::out_of_range& e) {
80865       {
80866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80867       };
80868     } catch (std::exception& e) {
80869       {
80870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80871       };
80872     } catch (Dali::DaliException e) {
80873       {
80874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80875       };
80876     } catch (...) {
80877       {
80878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80879       };
80880     }
80881   }
80882
80883   jresult = (void *)result;
80884   return jresult;
80885 }
80886
80887
80888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
80889   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
80890
80891   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
80892   {
80893     try {
80894       delete arg1;
80895     } catch (std::out_of_range& e) {
80896       {
80897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80898       };
80899     } catch (std::exception& e) {
80900       {
80901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80902       };
80903     } catch (Dali::DaliException e) {
80904       {
80905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80906       };
80907     } catch (...) {
80908       {
80909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80910       };
80911     }
80912   }
80913
80914 }
80915
80916
80917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
80918   void * jresult ;
80919   unsigned int arg1 ;
80920   unsigned int arg2 ;
80921   unsigned int arg3 ;
80922   unsigned int arg4 ;
80923   Dali::Toolkit::TableView::CellPosition *result = 0 ;
80924
80925   arg1 = (unsigned int)jarg1;
80926   arg2 = (unsigned int)jarg2;
80927   arg3 = (unsigned int)jarg3;
80928   arg4 = (unsigned int)jarg4;
80929   {
80930     try {
80931       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80939       };
80940     } catch (Dali::DaliException e) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80943       };
80944     } catch (...) {
80945       {
80946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80947       };
80948     }
80949   }
80950
80951   jresult = (void *)result;
80952   return jresult;
80953 }
80954
80955
80956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
80957   void * jresult ;
80958   unsigned int arg1 ;
80959   unsigned int arg2 ;
80960   unsigned int arg3 ;
80961   Dali::Toolkit::TableView::CellPosition *result = 0 ;
80962
80963   arg1 = (unsigned int)jarg1;
80964   arg2 = (unsigned int)jarg2;
80965   arg3 = (unsigned int)jarg3;
80966   {
80967     try {
80968       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
80969     } catch (std::out_of_range& e) {
80970       {
80971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80972       };
80973     } catch (std::exception& e) {
80974       {
80975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80976       };
80977     } catch (Dali::DaliException e) {
80978       {
80979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80980       };
80981     } catch (...) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80984       };
80985     }
80986   }
80987
80988   jresult = (void *)result;
80989   return jresult;
80990 }
80991
80992
80993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
80994   void * jresult ;
80995   unsigned int arg1 ;
80996   unsigned int arg2 ;
80997   Dali::Toolkit::TableView::CellPosition *result = 0 ;
80998
80999   arg1 = (unsigned int)jarg1;
81000   arg2 = (unsigned int)jarg2;
81001   {
81002     try {
81003       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81004     } catch (std::out_of_range& e) {
81005       {
81006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81007       };
81008     } catch (std::exception& e) {
81009       {
81010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81011       };
81012     } catch (Dali::DaliException e) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81015       };
81016     } catch (...) {
81017       {
81018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81019       };
81020     }
81021   }
81022
81023   jresult = (void *)result;
81024   return jresult;
81025 }
81026
81027
81028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81029   void * jresult ;
81030   unsigned int arg1 ;
81031   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81032
81033   arg1 = (unsigned int)jarg1;
81034   {
81035     try {
81036       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81037     } catch (std::out_of_range& e) {
81038       {
81039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81040       };
81041     } catch (std::exception& e) {
81042       {
81043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81044       };
81045     } catch (Dali::DaliException e) {
81046       {
81047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81048       };
81049     } catch (...) {
81050       {
81051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81052       };
81053     }
81054   }
81055
81056   jresult = (void *)result;
81057   return jresult;
81058 }
81059
81060
81061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81062   void * jresult ;
81063   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81064
81065   {
81066     try {
81067       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81068     } catch (std::out_of_range& e) {
81069       {
81070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81071       };
81072     } catch (std::exception& e) {
81073       {
81074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81075       };
81076     } catch (Dali::DaliException e) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81079       };
81080     } catch (...) {
81081       {
81082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81083       };
81084     }
81085   }
81086
81087   jresult = (void *)result;
81088   return jresult;
81089 }
81090
81091
81092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81093   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81094   unsigned int arg2 ;
81095
81096   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81097   arg2 = (unsigned int)jarg2;
81098   if (arg1) (arg1)->rowIndex = arg2;
81099 }
81100
81101
81102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81103   unsigned int jresult ;
81104   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81105   unsigned int result;
81106
81107   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81108   result = (unsigned int) ((arg1)->rowIndex);
81109   jresult = result;
81110   return jresult;
81111 }
81112
81113
81114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81115   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81116   unsigned int arg2 ;
81117
81118   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81119   arg2 = (unsigned int)jarg2;
81120   if (arg1) (arg1)->columnIndex = arg2;
81121 }
81122
81123
81124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81125   unsigned int jresult ;
81126   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81127   unsigned int result;
81128
81129   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81130   result = (unsigned int) ((arg1)->columnIndex);
81131   jresult = result;
81132   return jresult;
81133 }
81134
81135
81136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81137   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81138   unsigned int arg2 ;
81139
81140   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81141   arg2 = (unsigned int)jarg2;
81142   if (arg1) (arg1)->rowSpan = arg2;
81143 }
81144
81145
81146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81147   unsigned int jresult ;
81148   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81149   unsigned int result;
81150
81151   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81152   result = (unsigned int) ((arg1)->rowSpan);
81153   jresult = result;
81154   return jresult;
81155 }
81156
81157
81158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81159   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81160   unsigned int arg2 ;
81161
81162   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81163   arg2 = (unsigned int)jarg2;
81164   if (arg1) (arg1)->columnSpan = arg2;
81165 }
81166
81167
81168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81169   unsigned int jresult ;
81170   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81171   unsigned int result;
81172
81173   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81174   result = (unsigned int) ((arg1)->columnSpan);
81175   jresult = result;
81176   return jresult;
81177 }
81178
81179
81180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81181   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81182
81183   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81184   {
81185     try {
81186       delete arg1;
81187     } catch (std::out_of_range& e) {
81188       {
81189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81190       };
81191     } catch (std::exception& e) {
81192       {
81193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81194       };
81195     } catch (Dali::DaliException e) {
81196       {
81197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81198       };
81199     } catch (...) {
81200       {
81201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81202       };
81203     }
81204   }
81205
81206 }
81207
81208
81209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81210   void * jresult ;
81211   Dali::Toolkit::TableView *result = 0 ;
81212
81213   {
81214     try {
81215       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81216     } catch (std::out_of_range& e) {
81217       {
81218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81219       };
81220     } catch (std::exception& e) {
81221       {
81222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81223       };
81224     } catch (Dali::DaliException e) {
81225       {
81226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81227       };
81228     } catch (...) {
81229       {
81230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81231       };
81232     }
81233   }
81234
81235   jresult = (void *)result;
81236   return jresult;
81237 }
81238
81239
81240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81241   void * jresult ;
81242   Dali::Toolkit::TableView *arg1 = 0 ;
81243   Dali::Toolkit::TableView *result = 0 ;
81244
81245   arg1 = (Dali::Toolkit::TableView *)jarg1;
81246   if (!arg1) {
81247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81248     return 0;
81249   }
81250   {
81251     try {
81252       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81260       };
81261     } catch (Dali::DaliException e) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81264       };
81265     } catch (...) {
81266       {
81267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81268       };
81269     }
81270   }
81271
81272   jresult = (void *)result;
81273   return jresult;
81274 }
81275
81276
81277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81278   void * jresult ;
81279   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81280   Dali::Toolkit::TableView *arg2 = 0 ;
81281   Dali::Toolkit::TableView *result = 0 ;
81282
81283   arg1 = (Dali::Toolkit::TableView *)jarg1;
81284   arg2 = (Dali::Toolkit::TableView *)jarg2;
81285   if (!arg2) {
81286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81287     return 0;
81288   }
81289   {
81290     try {
81291       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81292     } catch (std::out_of_range& e) {
81293       {
81294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81295       };
81296     } catch (std::exception& e) {
81297       {
81298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81299       };
81300     } catch (Dali::DaliException e) {
81301       {
81302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81303       };
81304     } catch (...) {
81305       {
81306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81307       };
81308     }
81309   }
81310
81311   jresult = (void *)result;
81312   return jresult;
81313 }
81314
81315
81316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81317   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81318
81319   arg1 = (Dali::Toolkit::TableView *)jarg1;
81320   {
81321     try {
81322       delete arg1;
81323     } catch (std::out_of_range& e) {
81324       {
81325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81326       };
81327     } catch (std::exception& e) {
81328       {
81329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81330       };
81331     } catch (Dali::DaliException e) {
81332       {
81333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81334       };
81335     } catch (...) {
81336       {
81337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81338       };
81339     }
81340   }
81341
81342 }
81343
81344
81345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81346   void * jresult ;
81347   unsigned int arg1 ;
81348   unsigned int arg2 ;
81349   Dali::Toolkit::TableView result;
81350
81351   arg1 = (unsigned int)jarg1;
81352   arg2 = (unsigned int)jarg2;
81353   {
81354     try {
81355       result = Dali::Toolkit::TableView::New(arg1,arg2);
81356     } catch (std::out_of_range& e) {
81357       {
81358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81359       };
81360     } catch (std::exception& e) {
81361       {
81362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81363       };
81364     } catch (Dali::DaliException e) {
81365       {
81366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81367       };
81368     } catch (...) {
81369       {
81370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81371       };
81372     }
81373   }
81374
81375   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81376   return jresult;
81377 }
81378
81379
81380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81381   void * jresult ;
81382   Dali::BaseHandle arg1 ;
81383   Dali::BaseHandle *argp1 ;
81384   Dali::Toolkit::TableView result;
81385
81386   argp1 = (Dali::BaseHandle *)jarg1;
81387   if (!argp1) {
81388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81389     return 0;
81390   }
81391   arg1 = *argp1;
81392   {
81393     try {
81394       result = Dali::Toolkit::TableView::DownCast(arg1);
81395     } catch (std::out_of_range& e) {
81396       {
81397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81398       };
81399     } catch (std::exception& e) {
81400       {
81401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81402       };
81403     } catch (Dali::DaliException e) {
81404       {
81405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81406       };
81407     } catch (...) {
81408       {
81409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81410       };
81411     }
81412   }
81413
81414   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81415   return jresult;
81416 }
81417
81418
81419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81420   unsigned int jresult ;
81421   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81422   Dali::Actor arg2 ;
81423   Dali::Toolkit::TableView::CellPosition arg3 ;
81424   Dali::Actor *argp2 ;
81425   Dali::Toolkit::TableView::CellPosition *argp3 ;
81426   bool result;
81427
81428   arg1 = (Dali::Toolkit::TableView *)jarg1;
81429   argp2 = (Dali::Actor *)jarg2;
81430   if (!argp2) {
81431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81432     return 0;
81433   }
81434   arg2 = *argp2;
81435   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81436   if (!argp3) {
81437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81438     return 0;
81439   }
81440   arg3 = *argp3;
81441   {
81442     try {
81443       result = (bool)(arg1)->AddChild(arg2,arg3);
81444     } catch (std::out_of_range& e) {
81445       {
81446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81447       };
81448     } catch (std::exception& e) {
81449       {
81450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81451       };
81452     } catch (Dali::DaliException e) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81455       };
81456     } catch (...) {
81457       {
81458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81459       };
81460     }
81461   }
81462
81463   jresult = result;
81464   return jresult;
81465 }
81466
81467
81468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81469   void * jresult ;
81470   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81471   Dali::Toolkit::TableView::CellPosition arg2 ;
81472   Dali::Toolkit::TableView::CellPosition *argp2 ;
81473   Dali::Actor result;
81474
81475   arg1 = (Dali::Toolkit::TableView *)jarg1;
81476   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81477   if (!argp2) {
81478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81479     return 0;
81480   }
81481   arg2 = *argp2;
81482   {
81483     try {
81484       result = (arg1)->GetChildAt(arg2);
81485     } catch (std::out_of_range& e) {
81486       {
81487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81488       };
81489     } catch (std::exception& e) {
81490       {
81491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81492       };
81493     } catch (Dali::DaliException e) {
81494       {
81495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81496       };
81497     } catch (...) {
81498       {
81499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81500       };
81501     }
81502   }
81503
81504   jresult = new Dali::Actor((const Dali::Actor &)result);
81505   return jresult;
81506 }
81507
81508
81509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81510   void * jresult ;
81511   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81512   Dali::Toolkit::TableView::CellPosition arg2 ;
81513   Dali::Toolkit::TableView::CellPosition *argp2 ;
81514   Dali::Actor result;
81515
81516   arg1 = (Dali::Toolkit::TableView *)jarg1;
81517   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81518   if (!argp2) {
81519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81520     return 0;
81521   }
81522   arg2 = *argp2;
81523   {
81524     try {
81525       result = (arg1)->RemoveChildAt(arg2);
81526     } catch (std::out_of_range& e) {
81527       {
81528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81529       };
81530     } catch (std::exception& e) {
81531       {
81532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81533       };
81534     } catch (Dali::DaliException e) {
81535       {
81536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81537       };
81538     } catch (...) {
81539       {
81540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81541       };
81542     }
81543   }
81544
81545   jresult = new Dali::Actor((const Dali::Actor &)result);
81546   return jresult;
81547 }
81548
81549
81550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81551   unsigned int jresult ;
81552   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81553   Dali::Actor arg2 ;
81554   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81555   Dali::Actor *argp2 ;
81556   bool result;
81557
81558   arg1 = (Dali::Toolkit::TableView *)jarg1;
81559   argp2 = (Dali::Actor *)jarg2;
81560   if (!argp2) {
81561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81562     return 0;
81563   }
81564   arg2 = *argp2;
81565   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81566   if (!arg3) {
81567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81568     return 0;
81569   }
81570   {
81571     try {
81572       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81573     } catch (std::out_of_range& e) {
81574       {
81575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (std::exception& e) {
81578       {
81579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81580       };
81581     } catch (Dali::DaliException e) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81584       };
81585     } catch (...) {
81586       {
81587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81588       };
81589     }
81590   }
81591
81592   jresult = result;
81593   return jresult;
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81598   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81599   unsigned int arg2 ;
81600
81601   arg1 = (Dali::Toolkit::TableView *)jarg1;
81602   arg2 = (unsigned int)jarg2;
81603   {
81604     try {
81605       (arg1)->InsertRow(arg2);
81606     } catch (std::out_of_range& e) {
81607       {
81608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81609       };
81610     } catch (std::exception& e) {
81611       {
81612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (Dali::DaliException e) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81621       };
81622     }
81623   }
81624
81625 }
81626
81627
81628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81630   unsigned int arg2 ;
81631
81632   arg1 = (Dali::Toolkit::TableView *)jarg1;
81633   arg2 = (unsigned int)jarg2;
81634   {
81635     try {
81636       (arg1)->DeleteRow(arg2);
81637     } catch (std::out_of_range& e) {
81638       {
81639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81640       };
81641     } catch (std::exception& e) {
81642       {
81643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81644       };
81645     } catch (Dali::DaliException e) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81648       };
81649     } catch (...) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81652       };
81653     }
81654   }
81655
81656 }
81657
81658
81659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81661   unsigned int arg2 ;
81662   std::vector< Dali::Actor > *arg3 = 0 ;
81663
81664   arg1 = (Dali::Toolkit::TableView *)jarg1;
81665   arg2 = (unsigned int)jarg2;
81666   arg3 = (std::vector< Dali::Actor > *)jarg3;
81667   if (!arg3) {
81668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81669     return ;
81670   }
81671   {
81672     try {
81673       (arg1)->DeleteRow(arg2,*arg3);
81674     } catch (std::out_of_range& e) {
81675       {
81676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81677       };
81678     } catch (std::exception& e) {
81679       {
81680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81681       };
81682     } catch (Dali::DaliException e) {
81683       {
81684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81685       };
81686     } catch (...) {
81687       {
81688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81689       };
81690     }
81691   }
81692
81693 }
81694
81695
81696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81698   unsigned int arg2 ;
81699
81700   arg1 = (Dali::Toolkit::TableView *)jarg1;
81701   arg2 = (unsigned int)jarg2;
81702   {
81703     try {
81704       (arg1)->InsertColumn(arg2);
81705     } catch (std::out_of_range& e) {
81706       {
81707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81708       };
81709     } catch (std::exception& e) {
81710       {
81711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81712       };
81713     } catch (Dali::DaliException e) {
81714       {
81715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81716       };
81717     } catch (...) {
81718       {
81719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81720       };
81721     }
81722   }
81723
81724 }
81725
81726
81727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
81728   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81729   unsigned int arg2 ;
81730
81731   arg1 = (Dali::Toolkit::TableView *)jarg1;
81732   arg2 = (unsigned int)jarg2;
81733   {
81734     try {
81735       (arg1)->DeleteColumn(arg2);
81736     } catch (std::out_of_range& e) {
81737       {
81738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81739       };
81740     } catch (std::exception& e) {
81741       {
81742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81743       };
81744     } catch (Dali::DaliException e) {
81745       {
81746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81747       };
81748     } catch (...) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81751       };
81752     }
81753   }
81754
81755 }
81756
81757
81758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81759   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81760   unsigned int arg2 ;
81761   std::vector< Dali::Actor > *arg3 = 0 ;
81762
81763   arg1 = (Dali::Toolkit::TableView *)jarg1;
81764   arg2 = (unsigned int)jarg2;
81765   arg3 = (std::vector< Dali::Actor > *)jarg3;
81766   if (!arg3) {
81767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81768     return ;
81769   }
81770   {
81771     try {
81772       (arg1)->DeleteColumn(arg2,*arg3);
81773     } catch (std::out_of_range& e) {
81774       {
81775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81776       };
81777     } catch (std::exception& e) {
81778       {
81779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81780       };
81781     } catch (Dali::DaliException e) {
81782       {
81783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81784       };
81785     } catch (...) {
81786       {
81787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81788       };
81789     }
81790   }
81791
81792 }
81793
81794
81795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
81796   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81797   unsigned int arg2 ;
81798   unsigned int arg3 ;
81799
81800   arg1 = (Dali::Toolkit::TableView *)jarg1;
81801   arg2 = (unsigned int)jarg2;
81802   arg3 = (unsigned int)jarg3;
81803   {
81804     try {
81805       (arg1)->Resize(arg2,arg3);
81806     } catch (std::out_of_range& e) {
81807       {
81808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81809       };
81810     } catch (std::exception& e) {
81811       {
81812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81813       };
81814     } catch (Dali::DaliException e) {
81815       {
81816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81817       };
81818     } catch (...) {
81819       {
81820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81821       };
81822     }
81823   }
81824
81825 }
81826
81827
81828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
81829   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81830   unsigned int arg2 ;
81831   unsigned int arg3 ;
81832   std::vector< Dali::Actor > *arg4 = 0 ;
81833
81834   arg1 = (Dali::Toolkit::TableView *)jarg1;
81835   arg2 = (unsigned int)jarg2;
81836   arg3 = (unsigned int)jarg3;
81837   arg4 = (std::vector< Dali::Actor > *)jarg4;
81838   if (!arg4) {
81839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81840     return ;
81841   }
81842   {
81843     try {
81844       (arg1)->Resize(arg2,arg3,*arg4);
81845     } catch (std::out_of_range& e) {
81846       {
81847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81848       };
81849     } catch (std::exception& e) {
81850       {
81851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (Dali::DaliException e) {
81854       {
81855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81856       };
81857     } catch (...) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81860       };
81861     }
81862   }
81863
81864 }
81865
81866
81867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
81868   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81869   Dali::Size arg2 ;
81870   Dali::Size *argp2 ;
81871
81872   arg1 = (Dali::Toolkit::TableView *)jarg1;
81873   argp2 = (Dali::Size *)jarg2;
81874   if (!argp2) {
81875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
81876     return ;
81877   }
81878   arg2 = *argp2;
81879   {
81880     try {
81881       (arg1)->SetCellPadding(arg2);
81882     } catch (std::out_of_range& e) {
81883       {
81884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81885       };
81886     } catch (std::exception& e) {
81887       {
81888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81889       };
81890     } catch (Dali::DaliException e) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81893       };
81894     } catch (...) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81897       };
81898     }
81899   }
81900
81901 }
81902
81903
81904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
81905   void * jresult ;
81906   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81907   Dali::Size result;
81908
81909   arg1 = (Dali::Toolkit::TableView *)jarg1;
81910   {
81911     try {
81912       result = (arg1)->GetCellPadding();
81913     } catch (std::out_of_range& e) {
81914       {
81915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81916       };
81917     } catch (std::exception& e) {
81918       {
81919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81920       };
81921     } catch (Dali::DaliException e) {
81922       {
81923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81924       };
81925     } catch (...) {
81926       {
81927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81928       };
81929     }
81930   }
81931
81932   jresult = new Dali::Size((const Dali::Size &)result);
81933   return jresult;
81934 }
81935
81936
81937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
81938   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81939   unsigned int arg2 ;
81940
81941   arg1 = (Dali::Toolkit::TableView *)jarg1;
81942   arg2 = (unsigned int)jarg2;
81943   {
81944     try {
81945       (arg1)->SetFitHeight(arg2);
81946     } catch (std::out_of_range& e) {
81947       {
81948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81949       };
81950     } catch (std::exception& e) {
81951       {
81952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81953       };
81954     } catch (Dali::DaliException e) {
81955       {
81956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81957       };
81958     } catch (...) {
81959       {
81960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81961       };
81962     }
81963   }
81964
81965 }
81966
81967
81968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
81969   unsigned int jresult ;
81970   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81971   unsigned int arg2 ;
81972   bool result;
81973
81974   arg1 = (Dali::Toolkit::TableView *)jarg1;
81975   arg2 = (unsigned int)jarg2;
81976   {
81977     try {
81978       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81986       };
81987     } catch (Dali::DaliException e) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81990       };
81991     } catch (...) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81994       };
81995     }
81996   }
81997
81998   jresult = result;
81999   return jresult;
82000 }
82001
82002
82003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82004   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82005   unsigned int arg2 ;
82006
82007   arg1 = (Dali::Toolkit::TableView *)jarg1;
82008   arg2 = (unsigned int)jarg2;
82009   {
82010     try {
82011       (arg1)->SetFitWidth(arg2);
82012     } catch (std::out_of_range& e) {
82013       {
82014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82015       };
82016     } catch (std::exception& e) {
82017       {
82018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82019       };
82020     } catch (Dali::DaliException e) {
82021       {
82022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82023       };
82024     } catch (...) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82027       };
82028     }
82029   }
82030
82031 }
82032
82033
82034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82035   unsigned int jresult ;
82036   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82037   unsigned int arg2 ;
82038   bool result;
82039
82040   arg1 = (Dali::Toolkit::TableView *)jarg1;
82041   arg2 = (unsigned int)jarg2;
82042   {
82043     try {
82044       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82045     } catch (std::out_of_range& e) {
82046       {
82047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82048       };
82049     } catch (std::exception& e) {
82050       {
82051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82052       };
82053     } catch (Dali::DaliException e) {
82054       {
82055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82056       };
82057     } catch (...) {
82058       {
82059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82060       };
82061     }
82062   }
82063
82064   jresult = result;
82065   return jresult;
82066 }
82067
82068
82069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82070   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82071   unsigned int arg2 ;
82072   float arg3 ;
82073
82074   arg1 = (Dali::Toolkit::TableView *)jarg1;
82075   arg2 = (unsigned int)jarg2;
82076   arg3 = (float)jarg3;
82077   {
82078     try {
82079       (arg1)->SetFixedHeight(arg2,arg3);
82080     } catch (std::out_of_range& e) {
82081       {
82082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82083       };
82084     } catch (std::exception& e) {
82085       {
82086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82087       };
82088     } catch (Dali::DaliException e) {
82089       {
82090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82091       };
82092     } catch (...) {
82093       {
82094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82095       };
82096     }
82097   }
82098
82099 }
82100
82101
82102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82103   float jresult ;
82104   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82105   unsigned int arg2 ;
82106   float result;
82107
82108   arg1 = (Dali::Toolkit::TableView *)jarg1;
82109   arg2 = (unsigned int)jarg2;
82110   {
82111     try {
82112       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82113     } catch (std::out_of_range& e) {
82114       {
82115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82116       };
82117     } catch (std::exception& e) {
82118       {
82119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82120       };
82121     } catch (Dali::DaliException e) {
82122       {
82123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82124       };
82125     } catch (...) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82128       };
82129     }
82130   }
82131
82132   jresult = result;
82133   return jresult;
82134 }
82135
82136
82137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82138   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82139   unsigned int arg2 ;
82140   float arg3 ;
82141
82142   arg1 = (Dali::Toolkit::TableView *)jarg1;
82143   arg2 = (unsigned int)jarg2;
82144   arg3 = (float)jarg3;
82145   {
82146     try {
82147       (arg1)->SetRelativeHeight(arg2,arg3);
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (Dali::DaliException e) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82159       };
82160     } catch (...) {
82161       {
82162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82163       };
82164     }
82165   }
82166
82167 }
82168
82169
82170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82171   float jresult ;
82172   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82173   unsigned int arg2 ;
82174   float result;
82175
82176   arg1 = (Dali::Toolkit::TableView *)jarg1;
82177   arg2 = (unsigned int)jarg2;
82178   {
82179     try {
82180       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82181     } catch (std::out_of_range& e) {
82182       {
82183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82184       };
82185     } catch (std::exception& e) {
82186       {
82187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82188       };
82189     } catch (Dali::DaliException e) {
82190       {
82191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82192       };
82193     } catch (...) {
82194       {
82195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82196       };
82197     }
82198   }
82199
82200   jresult = result;
82201   return jresult;
82202 }
82203
82204
82205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82206   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82207   unsigned int arg2 ;
82208   float arg3 ;
82209
82210   arg1 = (Dali::Toolkit::TableView *)jarg1;
82211   arg2 = (unsigned int)jarg2;
82212   arg3 = (float)jarg3;
82213   {
82214     try {
82215       (arg1)->SetFixedWidth(arg2,arg3);
82216     } catch (std::out_of_range& e) {
82217       {
82218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82219       };
82220     } catch (std::exception& e) {
82221       {
82222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82223       };
82224     } catch (Dali::DaliException e) {
82225       {
82226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82227       };
82228     } catch (...) {
82229       {
82230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82231       };
82232     }
82233   }
82234
82235 }
82236
82237
82238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82239   float jresult ;
82240   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82241   unsigned int arg2 ;
82242   float result;
82243
82244   arg1 = (Dali::Toolkit::TableView *)jarg1;
82245   arg2 = (unsigned int)jarg2;
82246   {
82247     try {
82248       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82249     } catch (std::out_of_range& e) {
82250       {
82251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82252       };
82253     } catch (std::exception& e) {
82254       {
82255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82256       };
82257     } catch (Dali::DaliException e) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82260       };
82261     } catch (...) {
82262       {
82263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82264       };
82265     }
82266   }
82267
82268   jresult = result;
82269   return jresult;
82270 }
82271
82272
82273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82274   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82275   unsigned int arg2 ;
82276   float arg3 ;
82277
82278   arg1 = (Dali::Toolkit::TableView *)jarg1;
82279   arg2 = (unsigned int)jarg2;
82280   arg3 = (float)jarg3;
82281   {
82282     try {
82283       (arg1)->SetRelativeWidth(arg2,arg3);
82284     } catch (std::out_of_range& e) {
82285       {
82286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82287       };
82288     } catch (std::exception& e) {
82289       {
82290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82291       };
82292     } catch (Dali::DaliException e) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82295       };
82296     } catch (...) {
82297       {
82298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82299       };
82300     }
82301   }
82302
82303 }
82304
82305
82306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82307   float jresult ;
82308   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82309   unsigned int arg2 ;
82310   float result;
82311
82312   arg1 = (Dali::Toolkit::TableView *)jarg1;
82313   arg2 = (unsigned int)jarg2;
82314   {
82315     try {
82316       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82317     } catch (std::out_of_range& e) {
82318       {
82319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82320       };
82321     } catch (std::exception& e) {
82322       {
82323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82324       };
82325     } catch (Dali::DaliException e) {
82326       {
82327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82328       };
82329     } catch (...) {
82330       {
82331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82332       };
82333     }
82334   }
82335
82336   jresult = result;
82337   return jresult;
82338 }
82339
82340
82341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82342   unsigned int jresult ;
82343   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82344   unsigned int result;
82345
82346   arg1 = (Dali::Toolkit::TableView *)jarg1;
82347   {
82348     try {
82349       result = (unsigned int)(arg1)->GetRows();
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 unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82375   unsigned int jresult ;
82376   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82377   unsigned int result;
82378
82379   arg1 = (Dali::Toolkit::TableView *)jarg1;
82380   {
82381     try {
82382       result = (unsigned int)(arg1)->GetColumns();
82383     } catch (std::out_of_range& e) {
82384       {
82385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82386       };
82387     } catch (std::exception& e) {
82388       {
82389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82390       };
82391     } catch (Dali::DaliException e) {
82392       {
82393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82394       };
82395     } catch (...) {
82396       {
82397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82398       };
82399     }
82400   }
82401
82402   jresult = result;
82403   return jresult;
82404 }
82405
82406
82407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82408   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82409   Dali::Toolkit::TableView::CellPosition arg2 ;
82410   Dali::HorizontalAlignment::Type arg3 ;
82411   Dali::VerticalAlignment::Type arg4 ;
82412   Dali::Toolkit::TableView::CellPosition *argp2 ;
82413
82414   arg1 = (Dali::Toolkit::TableView *)jarg1;
82415   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82416   if (!argp2) {
82417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82418     return ;
82419   }
82420   arg2 = *argp2;
82421   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82422   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82423   {
82424     try {
82425       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82426     } catch (std::out_of_range& e) {
82427       {
82428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82429       };
82430     } catch (std::exception& e) {
82431       {
82432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82433       };
82434     } catch (Dali::DaliException e) {
82435       {
82436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82437       };
82438     } catch (...) {
82439       {
82440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82441       };
82442     }
82443   }
82444
82445 }
82446
82447
82448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82449   unsigned int jresult ;
82450   unsigned int result;
82451
82452   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82453   jresult = result;
82454   return jresult;
82455 }
82456
82457
82458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82459   int jresult ;
82460   int result;
82461
82462   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82463   jresult = (int)result;
82464   return jresult;
82465 }
82466
82467
82468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82469   int jresult ;
82470   int result;
82471
82472   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82473   jresult = (int)result;
82474   return jresult;
82475 }
82476
82477
82478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82479   int jresult ;
82480   int result;
82481
82482   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82483   jresult = (int)result;
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82489   int jresult ;
82490   int result;
82491
82492   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82493   jresult = (int)result;
82494   return jresult;
82495 }
82496
82497
82498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82499   int jresult ;
82500   int result;
82501
82502   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82503   jresult = (int)result;
82504   return jresult;
82505 }
82506
82507
82508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82509   int jresult ;
82510   int result;
82511
82512   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82513   jresult = (int)result;
82514   return jresult;
82515 }
82516
82517
82518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82519   int jresult ;
82520   int result;
82521
82522   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82523   jresult = (int)result;
82524   return jresult;
82525 }
82526
82527
82528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82529   int jresult ;
82530   int result;
82531
82532   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82533   jresult = (int)result;
82534   return jresult;
82535 }
82536
82537
82538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82539   int jresult ;
82540   int result;
82541
82542   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82543   jresult = (int)result;
82544   return jresult;
82545 }
82546
82547
82548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82549   int jresult ;
82550   int result;
82551
82552   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82553   jresult = (int)result;
82554   return jresult;
82555 }
82556
82557
82558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82559   int jresult ;
82560   int result;
82561
82562   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82563   jresult = (int)result;
82564   return jresult;
82565 }
82566
82567
82568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82569   int jresult ;
82570   int result;
82571
82572   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82573   jresult = (int)result;
82574   return jresult;
82575 }
82576
82577
82578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82579   int jresult ;
82580   int result;
82581
82582   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82583   jresult = (int)result;
82584   return jresult;
82585 }
82586
82587
82588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82589   int jresult ;
82590   int result;
82591
82592   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82593   jresult = (int)result;
82594   return jresult;
82595 }
82596
82597
82598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82599   int jresult ;
82600   int result;
82601
82602   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82603   jresult = (int)result;
82604   return jresult;
82605 }
82606
82607
82608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82609   int jresult ;
82610   int result;
82611
82612   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82613   jresult = (int)result;
82614   return jresult;
82615 }
82616
82617
82618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82619   int jresult ;
82620   int result;
82621
82622   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82623   jresult = (int)result;
82624   return jresult;
82625 }
82626
82627
82628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82629   int jresult ;
82630   int result;
82631
82632   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82633   jresult = (int)result;
82634   return jresult;
82635 }
82636
82637
82638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82639   int jresult ;
82640   int result;
82641
82642   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82643   jresult = (int)result;
82644   return jresult;
82645 }
82646
82647
82648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82649   void * jresult ;
82650   Dali::Toolkit::TextLabel::Property *result = 0 ;
82651
82652   {
82653     try {
82654       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
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 = (void *)result;
82675   return jresult;
82676 }
82677
82678
82679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82680   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82681
82682   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82683   {
82684     try {
82685       delete arg1;
82686     } catch (std::out_of_range& e) {
82687       {
82688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82689       };
82690     } catch (std::exception& e) {
82691       {
82692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82693       };
82694     } catch (Dali::DaliException e) {
82695       {
82696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82697       };
82698     } catch (...) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82701       };
82702     }
82703   }
82704
82705 }
82706
82707
82708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
82709   void * jresult ;
82710   Dali::Toolkit::TextLabel result;
82711
82712   {
82713     try {
82714       result = Dali::Toolkit::TextLabel::New();
82715     } catch (std::out_of_range& e) {
82716       {
82717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82718       };
82719     } catch (std::exception& e) {
82720       {
82721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (Dali::DaliException e) {
82724       {
82725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82726       };
82727     } catch (...) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82730       };
82731     }
82732   }
82733
82734   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82735   return jresult;
82736 }
82737
82738
82739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
82740   void * jresult ;
82741   std::string *arg1 = 0 ;
82742   Dali::Toolkit::TextLabel result;
82743
82744   if (!jarg1) {
82745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82746     return 0;
82747   }
82748   std::string arg1_str(jarg1);
82749   arg1 = &arg1_str;
82750   {
82751     try {
82752       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
82753     } catch (std::out_of_range& e) {
82754       {
82755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (std::exception& e) {
82758       {
82759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82760       };
82761     } catch (Dali::DaliException e) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82764       };
82765     } catch (...) {
82766       {
82767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82768       };
82769     }
82770   }
82771
82772   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82773
82774   //argout typemap for const std::string&
82775
82776   return jresult;
82777 }
82778
82779
82780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
82781   void * jresult ;
82782   Dali::Toolkit::TextLabel *result = 0 ;
82783
82784   {
82785     try {
82786       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
82787     } catch (std::out_of_range& e) {
82788       {
82789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82790       };
82791     } catch (std::exception& e) {
82792       {
82793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (Dali::DaliException e) {
82796       {
82797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82798       };
82799     } catch (...) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82802       };
82803     }
82804   }
82805
82806   jresult = (void *)result;
82807   return jresult;
82808 }
82809
82810
82811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
82812   void * jresult ;
82813   Dali::Toolkit::TextLabel *arg1 = 0 ;
82814   Dali::Toolkit::TextLabel *result = 0 ;
82815
82816   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
82817   if (!arg1) {
82818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
82819     return 0;
82820   }
82821   {
82822     try {
82823       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
82824     } catch (std::out_of_range& e) {
82825       {
82826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82827       };
82828     } catch (std::exception& e) {
82829       {
82830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82831       };
82832     } catch (Dali::DaliException e) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82835       };
82836     } catch (...) {
82837       {
82838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82839       };
82840     }
82841   }
82842
82843   jresult = (void *)result;
82844   return jresult;
82845 }
82846
82847
82848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
82849   void * jresult ;
82850   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
82851   Dali::Toolkit::TextLabel *arg2 = 0 ;
82852   Dali::Toolkit::TextLabel *result = 0 ;
82853
82854   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
82855   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
82856   if (!arg2) {
82857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
82858     return 0;
82859   }
82860   {
82861     try {
82862       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
82863     } catch (std::out_of_range& e) {
82864       {
82865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82866       };
82867     } catch (std::exception& e) {
82868       {
82869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82870       };
82871     } catch (Dali::DaliException e) {
82872       {
82873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82874       };
82875     } catch (...) {
82876       {
82877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82878       };
82879     }
82880   }
82881
82882   jresult = (void *)result;
82883   return jresult;
82884 }
82885
82886
82887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
82888   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
82889
82890   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
82891   {
82892     try {
82893       delete arg1;
82894     } catch (std::out_of_range& e) {
82895       {
82896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82897       };
82898     } catch (std::exception& e) {
82899       {
82900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82901       };
82902     } catch (Dali::DaliException e) {
82903       {
82904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82905       };
82906     } catch (...) {
82907       {
82908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82909       };
82910     }
82911   }
82912
82913 }
82914
82915
82916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
82917   void * jresult ;
82918   Dali::BaseHandle arg1 ;
82919   Dali::BaseHandle *argp1 ;
82920   Dali::Toolkit::TextLabel result;
82921
82922   argp1 = (Dali::BaseHandle *)jarg1;
82923   if (!argp1) {
82924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82925     return 0;
82926   }
82927   arg1 = *argp1;
82928   {
82929     try {
82930       result = Dali::Toolkit::TextLabel::DownCast(arg1);
82931     } catch (std::out_of_range& e) {
82932       {
82933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82934       };
82935     } catch (std::exception& e) {
82936       {
82937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82938       };
82939     } catch (Dali::DaliException e) {
82940       {
82941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82942       };
82943     } catch (...) {
82944       {
82945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82946       };
82947     }
82948   }
82949
82950   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82951   return jresult;
82952 }
82953
82954
82955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
82956   void * jresult ;
82957   Dali::Toolkit::AccessibilityManager *result = 0 ;
82958
82959   {
82960     try {
82961       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
82962     } catch (std::out_of_range& e) {
82963       {
82964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82965       };
82966     } catch (std::exception& e) {
82967       {
82968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82969       };
82970     } catch (Dali::DaliException e) {
82971       {
82972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82973       };
82974     } catch (...) {
82975       {
82976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82977       };
82978     }
82979   }
82980
82981   jresult = (void *)result;
82982   return jresult;
82983 }
82984
82985
82986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
82987   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82988
82989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82990   {
82991     try {
82992       delete arg1;
82993     } catch (std::out_of_range& e) {
82994       {
82995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82996       };
82997     } catch (std::exception& e) {
82998       {
82999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83000       };
83001     } catch (Dali::DaliException e) {
83002       {
83003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83004       };
83005     } catch (...) {
83006       {
83007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83008       };
83009     }
83010   }
83011
83012 }
83013
83014
83015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83016   void * jresult ;
83017   Dali::Toolkit::AccessibilityManager result;
83018
83019   {
83020     try {
83021       result = Dali::Toolkit::AccessibilityManager::Get();
83022     } catch (std::out_of_range& e) {
83023       {
83024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83025       };
83026     } catch (std::exception& e) {
83027       {
83028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83029       };
83030     } catch (Dali::DaliException e) {
83031       {
83032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83033       };
83034     } catch (...) {
83035       {
83036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83037       };
83038     }
83039   }
83040
83041   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83042   return jresult;
83043 }
83044
83045
83046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83048   Dali::Actor arg2 ;
83049   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83050   std::string *arg4 = 0 ;
83051   Dali::Actor *argp2 ;
83052
83053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83054   argp2 = (Dali::Actor *)jarg2;
83055   if (!argp2) {
83056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83057     return ;
83058   }
83059   arg2 = *argp2;
83060   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83061   if (!jarg4) {
83062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83063     return ;
83064   }
83065   std::string arg4_str(jarg4);
83066   arg4 = &arg4_str;
83067   {
83068     try {
83069       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83070     } catch (std::out_of_range& e) {
83071       {
83072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83073       };
83074     } catch (std::exception& e) {
83075       {
83076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83077       };
83078     } catch (Dali::DaliException e) {
83079       {
83080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83081       };
83082     } catch (...) {
83083       {
83084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83085       };
83086     }
83087   }
83088
83089
83090   //argout typemap for const std::string&
83091
83092 }
83093
83094
83095 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83096   char * jresult ;
83097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83098   Dali::Actor arg2 ;
83099   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83100   Dali::Actor *argp2 ;
83101   std::string result;
83102
83103   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83104   argp2 = (Dali::Actor *)jarg2;
83105   if (!argp2) {
83106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83107     return 0;
83108   }
83109   arg2 = *argp2;
83110   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83111   {
83112     try {
83113       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83114     } catch (std::out_of_range& e) {
83115       {
83116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83117       };
83118     } catch (std::exception& e) {
83119       {
83120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83121       };
83122     } catch (Dali::DaliException e) {
83123       {
83124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83125       };
83126     } catch (...) {
83127       {
83128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83129       };
83130     }
83131   }
83132
83133   jresult = SWIG_csharp_string_callback((&result)->c_str());
83134   return jresult;
83135 }
83136
83137
83138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83140   Dali::Actor arg2 ;
83141   unsigned int arg3 ;
83142   Dali::Actor *argp2 ;
83143
83144   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83145   argp2 = (Dali::Actor *)jarg2;
83146   if (!argp2) {
83147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83148     return ;
83149   }
83150   arg2 = *argp2;
83151   arg3 = (unsigned int)jarg3;
83152   {
83153     try {
83154       (arg1)->SetFocusOrder(arg2,arg3);
83155     } catch (std::out_of_range& e) {
83156       {
83157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83158       };
83159     } catch (std::exception& e) {
83160       {
83161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83162       };
83163     } catch (Dali::DaliException e) {
83164       {
83165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83166       };
83167     } catch (...) {
83168       {
83169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83170       };
83171     }
83172   }
83173
83174 }
83175
83176
83177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83178   unsigned int jresult ;
83179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83180   Dali::Actor arg2 ;
83181   Dali::Actor *argp2 ;
83182   unsigned int result;
83183
83184   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83185   argp2 = (Dali::Actor *)jarg2;
83186   if (!argp2) {
83187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83188     return 0;
83189   }
83190   arg2 = *argp2;
83191   {
83192     try {
83193       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83194     } catch (std::out_of_range& e) {
83195       {
83196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83197       };
83198     } catch (std::exception& e) {
83199       {
83200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83201       };
83202     } catch (Dali::DaliException e) {
83203       {
83204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83205       };
83206     } catch (...) {
83207       {
83208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83209       };
83210     }
83211   }
83212
83213   jresult = result;
83214   return jresult;
83215 }
83216
83217
83218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83219   unsigned int jresult ;
83220   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83221   unsigned int result;
83222
83223   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83224   {
83225     try {
83226       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83227     } catch (std::out_of_range& e) {
83228       {
83229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83230       };
83231     } catch (std::exception& e) {
83232       {
83233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83234       };
83235     } catch (Dali::DaliException e) {
83236       {
83237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83238       };
83239     } catch (...) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83242       };
83243     }
83244   }
83245
83246   jresult = result;
83247   return jresult;
83248 }
83249
83250
83251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83252   void * jresult ;
83253   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83254   unsigned int arg2 ;
83255   Dali::Actor result;
83256
83257   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83258   arg2 = (unsigned int)jarg2;
83259   {
83260     try {
83261       result = (arg1)->GetActorByFocusOrder(arg2);
83262     } catch (std::out_of_range& e) {
83263       {
83264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83265       };
83266     } catch (std::exception& e) {
83267       {
83268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83269       };
83270     } catch (Dali::DaliException e) {
83271       {
83272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83273       };
83274     } catch (...) {
83275       {
83276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83277       };
83278     }
83279   }
83280
83281   jresult = new Dali::Actor((const Dali::Actor &)result);
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83287   unsigned int jresult ;
83288   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83289   Dali::Actor arg2 ;
83290   Dali::Actor *argp2 ;
83291   bool result;
83292
83293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83294   argp2 = (Dali::Actor *)jarg2;
83295   if (!argp2) {
83296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83297     return 0;
83298   }
83299   arg2 = *argp2;
83300   {
83301     try {
83302       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (Dali::DaliException e) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83314       };
83315     } catch (...) {
83316       {
83317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83318       };
83319     }
83320   }
83321
83322   jresult = result;
83323   return jresult;
83324 }
83325
83326
83327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83328   void * jresult ;
83329   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83330   Dali::Actor result;
83331
83332   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83333   {
83334     try {
83335       result = (arg1)->GetCurrentFocusActor();
83336     } catch (std::out_of_range& e) {
83337       {
83338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83339       };
83340     } catch (std::exception& e) {
83341       {
83342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83343       };
83344     } catch (Dali::DaliException e) {
83345       {
83346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83347       };
83348     } catch (...) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83351       };
83352     }
83353   }
83354
83355   jresult = new Dali::Actor((const Dali::Actor &)result);
83356   return jresult;
83357 }
83358
83359
83360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83361   void * jresult ;
83362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83363   Dali::Actor result;
83364
83365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83366   {
83367     try {
83368       result = (arg1)->GetCurrentFocusGroup();
83369     } catch (std::out_of_range& e) {
83370       {
83371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83372       };
83373     } catch (std::exception& e) {
83374       {
83375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83376       };
83377     } catch (Dali::DaliException e) {
83378       {
83379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83380       };
83381     } catch (...) {
83382       {
83383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83384       };
83385     }
83386   }
83387
83388   jresult = new Dali::Actor((const Dali::Actor &)result);
83389   return jresult;
83390 }
83391
83392
83393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83394   unsigned int jresult ;
83395   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83396   unsigned int result;
83397
83398   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83399   {
83400     try {
83401       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83402     } catch (std::out_of_range& e) {
83403       {
83404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83405       };
83406     } catch (std::exception& e) {
83407       {
83408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83409       };
83410     } catch (Dali::DaliException e) {
83411       {
83412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83413       };
83414     } catch (...) {
83415       {
83416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83417       };
83418     }
83419   }
83420
83421   jresult = result;
83422   return jresult;
83423 }
83424
83425
83426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83427   unsigned int jresult ;
83428   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83429   bool result;
83430
83431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83432   {
83433     try {
83434       result = (bool)(arg1)->MoveFocusForward();
83435     } catch (std::out_of_range& e) {
83436       {
83437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83438       };
83439     } catch (std::exception& e) {
83440       {
83441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83442       };
83443     } catch (Dali::DaliException e) {
83444       {
83445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83446       };
83447     } catch (...) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83450       };
83451     }
83452   }
83453
83454   jresult = result;
83455   return jresult;
83456 }
83457
83458
83459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83460   unsigned int jresult ;
83461   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83462   bool result;
83463
83464   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83465   {
83466     try {
83467       result = (bool)(arg1)->MoveFocusBackward();
83468     } catch (std::out_of_range& e) {
83469       {
83470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83471       };
83472     } catch (std::exception& e) {
83473       {
83474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83475       };
83476     } catch (Dali::DaliException e) {
83477       {
83478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83479       };
83480     } catch (...) {
83481       {
83482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83483       };
83484     }
83485   }
83486
83487   jresult = result;
83488   return jresult;
83489 }
83490
83491
83492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83493   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83494
83495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83496   {
83497     try {
83498       (arg1)->ClearFocus();
83499     } catch (std::out_of_range& e) {
83500       {
83501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83502       };
83503     } catch (std::exception& e) {
83504       {
83505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83506       };
83507     } catch (Dali::DaliException e) {
83508       {
83509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83510       };
83511     } catch (...) {
83512       {
83513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83514       };
83515     }
83516   }
83517
83518 }
83519
83520
83521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83523
83524   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83525   {
83526     try {
83527       (arg1)->Reset();
83528     } catch (std::out_of_range& e) {
83529       {
83530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83531       };
83532     } catch (std::exception& e) {
83533       {
83534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83535       };
83536     } catch (Dali::DaliException e) {
83537       {
83538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83539       };
83540     } catch (...) {
83541       {
83542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83543       };
83544     }
83545   }
83546
83547 }
83548
83549
83550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83551   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83552   Dali::Actor arg2 ;
83553   bool arg3 ;
83554   Dali::Actor *argp2 ;
83555
83556   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83557   argp2 = (Dali::Actor *)jarg2;
83558   if (!argp2) {
83559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83560     return ;
83561   }
83562   arg2 = *argp2;
83563   arg3 = jarg3 ? true : false;
83564   {
83565     try {
83566       (arg1)->SetFocusGroup(arg2,arg3);
83567     } catch (std::out_of_range& e) {
83568       {
83569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83570       };
83571     } catch (std::exception& e) {
83572       {
83573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83574       };
83575     } catch (Dali::DaliException e) {
83576       {
83577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83578       };
83579     } catch (...) {
83580       {
83581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83582       };
83583     }
83584   }
83585
83586 }
83587
83588
83589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83590   unsigned int jresult ;
83591   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83592   Dali::Actor arg2 ;
83593   Dali::Actor *argp2 ;
83594   bool result;
83595
83596   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83597   argp2 = (Dali::Actor *)jarg2;
83598   if (!argp2) {
83599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83600     return 0;
83601   }
83602   arg2 = *argp2;
83603   {
83604     try {
83605       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83606     } catch (std::out_of_range& e) {
83607       {
83608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83609       };
83610     } catch (std::exception& e) {
83611       {
83612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83613       };
83614     } catch (Dali::DaliException e) {
83615       {
83616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83617       };
83618     } catch (...) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83621       };
83622     }
83623   }
83624
83625   jresult = result;
83626   return jresult;
83627 }
83628
83629
83630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83632   bool arg2 ;
83633
83634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83635   arg2 = jarg2 ? true : false;
83636   {
83637     try {
83638       (arg1)->SetGroupMode(arg2);
83639     } catch (std::out_of_range& e) {
83640       {
83641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83642       };
83643     } catch (std::exception& e) {
83644       {
83645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83646       };
83647     } catch (Dali::DaliException e) {
83648       {
83649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83654       };
83655     }
83656   }
83657
83658 }
83659
83660
83661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83662   unsigned int jresult ;
83663   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83664   bool result;
83665
83666   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83667   {
83668     try {
83669       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83670     } catch (std::out_of_range& e) {
83671       {
83672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83673       };
83674     } catch (std::exception& e) {
83675       {
83676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83677       };
83678     } catch (Dali::DaliException e) {
83679       {
83680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83681       };
83682     } catch (...) {
83683       {
83684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83685       };
83686     }
83687   }
83688
83689   jresult = result;
83690   return jresult;
83691 }
83692
83693
83694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83696   bool arg2 ;
83697
83698   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83699   arg2 = jarg2 ? true : false;
83700   {
83701     try {
83702       (arg1)->SetWrapMode(arg2);
83703     } catch (std::out_of_range& e) {
83704       {
83705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83706       };
83707     } catch (std::exception& e) {
83708       {
83709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83710       };
83711     } catch (Dali::DaliException e) {
83712       {
83713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83714       };
83715     } catch (...) {
83716       {
83717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83718       };
83719     }
83720   }
83721
83722 }
83723
83724
83725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
83726   unsigned int jresult ;
83727   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83728   bool result;
83729
83730   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83731   {
83732     try {
83733       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
83734     } catch (std::out_of_range& e) {
83735       {
83736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83737       };
83738     } catch (std::exception& e) {
83739       {
83740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83741       };
83742     } catch (Dali::DaliException e) {
83743       {
83744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83745       };
83746     } catch (...) {
83747       {
83748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83749       };
83750     }
83751   }
83752
83753   jresult = result;
83754   return jresult;
83755 }
83756
83757
83758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
83759   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83760   Dali::Actor arg2 ;
83761   Dali::Actor *argp2 ;
83762
83763   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83764   argp2 = (Dali::Actor *)jarg2;
83765   if (!argp2) {
83766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83767     return ;
83768   }
83769   arg2 = *argp2;
83770   {
83771     try {
83772       (arg1)->SetFocusIndicatorActor(arg2);
83773     } catch (std::out_of_range& e) {
83774       {
83775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83776       };
83777     } catch (std::exception& e) {
83778       {
83779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83780       };
83781     } catch (Dali::DaliException e) {
83782       {
83783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83784       };
83785     } catch (...) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83788       };
83789     }
83790   }
83791
83792 }
83793
83794
83795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
83796   void * jresult ;
83797   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83798   Dali::Actor result;
83799
83800   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83801   {
83802     try {
83803       result = (arg1)->GetFocusIndicatorActor();
83804     } catch (std::out_of_range& e) {
83805       {
83806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83807       };
83808     } catch (std::exception& e) {
83809       {
83810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83811       };
83812     } catch (Dali::DaliException e) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83819       };
83820     }
83821   }
83822
83823   jresult = new Dali::Actor((const Dali::Actor &)result);
83824   return jresult;
83825 }
83826
83827
83828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
83829   void * jresult ;
83830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83831   Dali::Actor arg2 ;
83832   Dali::Actor *argp2 ;
83833   Dali::Actor result;
83834
83835   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83836   argp2 = (Dali::Actor *)jarg2;
83837   if (!argp2) {
83838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83839     return 0;
83840   }
83841   arg2 = *argp2;
83842   {
83843     try {
83844       result = (arg1)->GetFocusGroup(arg2);
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83852       };
83853     } catch (Dali::DaliException e) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83856       };
83857     } catch (...) {
83858       {
83859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83860       };
83861     }
83862   }
83863
83864   jresult = new Dali::Actor((const Dali::Actor &)result);
83865   return jresult;
83866 }
83867
83868
83869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
83870   void * jresult ;
83871   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83872   Dali::Vector2 result;
83873
83874   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83875   {
83876     try {
83877       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
83878     } catch (std::out_of_range& e) {
83879       {
83880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83881       };
83882     } catch (std::exception& e) {
83883       {
83884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83885       };
83886     } catch (Dali::DaliException e) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83889       };
83890     } catch (...) {
83891       {
83892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83893       };
83894     }
83895   }
83896
83897   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
83898   return jresult;
83899 }
83900
83901
83902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
83903   void * jresult ;
83904   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83905   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
83906
83907   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83908   {
83909     try {
83910       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
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 = (void *)result;
83931   return jresult;
83932 }
83933
83934
83935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
83936   void * jresult ;
83937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83938   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
83939
83940   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83941   {
83942     try {
83943       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
83944     } catch (std::out_of_range& e) {
83945       {
83946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83947       };
83948     } catch (std::exception& e) {
83949       {
83950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83951       };
83952     } catch (Dali::DaliException e) {
83953       {
83954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83955       };
83956     } catch (...) {
83957       {
83958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83959       };
83960     }
83961   }
83962
83963   jresult = (void *)result;
83964   return jresult;
83965 }
83966
83967
83968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
83969   void * jresult ;
83970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83971   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
83972
83973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83974   {
83975     try {
83976       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
83977     } catch (std::out_of_range& e) {
83978       {
83979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83980       };
83981     } catch (std::exception& e) {
83982       {
83983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83984       };
83985     } catch (Dali::DaliException e) {
83986       {
83987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83988       };
83989     } catch (...) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83992       };
83993     }
83994   }
83995
83996   jresult = (void *)result;
83997   return jresult;
83998 }
83999
84000
84001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84002   void * jresult ;
84003   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84004   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84005
84006   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84007   {
84008     try {
84009       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84010     } catch (std::out_of_range& e) {
84011       {
84012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84013       };
84014     } catch (std::exception& e) {
84015       {
84016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84017       };
84018     } catch (Dali::DaliException e) {
84019       {
84020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84021       };
84022     } catch (...) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84025       };
84026     }
84027   }
84028
84029   jresult = (void *)result;
84030   return jresult;
84031 }
84032
84033
84034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84035   void * jresult ;
84036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84037   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84038
84039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84040   {
84041     try {
84042       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84043     } catch (std::out_of_range& e) {
84044       {
84045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (std::exception& e) {
84048       {
84049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84050       };
84051     } catch (Dali::DaliException e) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84054       };
84055     } catch (...) {
84056       {
84057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84058       };
84059     }
84060   }
84061
84062   jresult = (void *)result;
84063   return jresult;
84064 }
84065
84066
84067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84068   void * jresult ;
84069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84070   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84071
84072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84073   {
84074     try {
84075       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84076     } catch (std::out_of_range& e) {
84077       {
84078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84079       };
84080     } catch (std::exception& e) {
84081       {
84082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84083       };
84084     } catch (Dali::DaliException e) {
84085       {
84086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84087       };
84088     } catch (...) {
84089       {
84090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84091       };
84092     }
84093   }
84094
84095   jresult = (void *)result;
84096   return jresult;
84097 }
84098
84099
84100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84101   void * jresult ;
84102   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84103   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84104
84105   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84106   {
84107     try {
84108       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
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 = (void *)result;
84129   return jresult;
84130 }
84131
84132
84133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84134   void * jresult ;
84135   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84136   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84137
84138   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84139   {
84140     try {
84141       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84142     } catch (std::out_of_range& e) {
84143       {
84144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84145       };
84146     } catch (std::exception& e) {
84147       {
84148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84149       };
84150     } catch (Dali::DaliException e) {
84151       {
84152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84153       };
84154     } catch (...) {
84155       {
84156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84157       };
84158     }
84159   }
84160
84161   jresult = (void *)result;
84162   return jresult;
84163 }
84164
84165
84166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84167   void * jresult ;
84168   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84169   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84170
84171   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84172   {
84173     try {
84174       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84175     } catch (std::out_of_range& e) {
84176       {
84177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84178       };
84179     } catch (std::exception& e) {
84180       {
84181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84182       };
84183     } catch (Dali::DaliException e) {
84184       {
84185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84186       };
84187     } catch (...) {
84188       {
84189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84190       };
84191     }
84192   }
84193
84194   jresult = (void *)result;
84195   return jresult;
84196 }
84197
84198
84199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84200   void * jresult ;
84201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84202   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84203
84204   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84205   {
84206     try {
84207       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84208     } catch (std::out_of_range& e) {
84209       {
84210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84211       };
84212     } catch (std::exception& e) {
84213       {
84214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84215       };
84216     } catch (Dali::DaliException e) {
84217       {
84218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84219       };
84220     } catch (...) {
84221       {
84222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84223       };
84224     }
84225   }
84226
84227   jresult = (void *)result;
84228   return jresult;
84229 }
84230
84231
84232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84233   void * jresult ;
84234   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84235   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84236
84237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84238   {
84239     try {
84240       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84241     } catch (std::out_of_range& e) {
84242       {
84243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84244       };
84245     } catch (std::exception& e) {
84246       {
84247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (Dali::DaliException e) {
84250       {
84251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84252       };
84253     } catch (...) {
84254       {
84255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84256       };
84257     }
84258   }
84259
84260   jresult = (void *)result;
84261   return jresult;
84262 }
84263
84264
84265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84266   void * jresult ;
84267   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84268   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84269
84270   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84271   {
84272     try {
84273       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84274     } catch (std::out_of_range& e) {
84275       {
84276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84277       };
84278     } catch (std::exception& e) {
84279       {
84280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84281       };
84282     } catch (Dali::DaliException e) {
84283       {
84284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84285       };
84286     } catch (...) {
84287       {
84288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84289       };
84290     }
84291   }
84292
84293   jresult = (void *)result;
84294   return jresult;
84295 }
84296
84297
84298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84299   void * jresult ;
84300   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84301   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84302
84303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84304   {
84305     try {
84306       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84307     } catch (std::out_of_range& e) {
84308       {
84309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84310       };
84311     } catch (std::exception& e) {
84312       {
84313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84314       };
84315     } catch (Dali::DaliException e) {
84316       {
84317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84318       };
84319     } catch (...) {
84320       {
84321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84322       };
84323     }
84324   }
84325
84326   jresult = (void *)result;
84327   return jresult;
84328 }
84329
84330
84331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84332   void * jresult ;
84333   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84334   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84335
84336   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84337   {
84338     try {
84339       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84340     } catch (std::out_of_range& e) {
84341       {
84342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84343       };
84344     } catch (std::exception& e) {
84345       {
84346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84347       };
84348     } catch (Dali::DaliException e) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84351       };
84352     } catch (...) {
84353       {
84354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84355       };
84356     }
84357   }
84358
84359   jresult = (void *)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84365   void * jresult ;
84366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84367   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84368
84369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84370   {
84371     try {
84372       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84373     } catch (std::out_of_range& e) {
84374       {
84375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84376       };
84377     } catch (std::exception& e) {
84378       {
84379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84380       };
84381     } catch (Dali::DaliException e) {
84382       {
84383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84384       };
84385     } catch (...) {
84386       {
84387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84388       };
84389     }
84390   }
84391
84392   jresult = (void *)result;
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84398   void * jresult ;
84399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84400   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84401
84402   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84403   {
84404     try {
84405       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84406     } catch (std::out_of_range& e) {
84407       {
84408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (std::exception& e) {
84411       {
84412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84413       };
84414     } catch (Dali::DaliException e) {
84415       {
84416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84417       };
84418     } catch (...) {
84419       {
84420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84421       };
84422     }
84423   }
84424
84425   jresult = (void *)result;
84426   return jresult;
84427 }
84428
84429
84430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84431   void * jresult ;
84432   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84433   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84434
84435   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84436   {
84437     try {
84438       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84439     } catch (std::out_of_range& e) {
84440       {
84441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (std::exception& e) {
84444       {
84445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84446       };
84447     } catch (Dali::DaliException e) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84450       };
84451     } catch (...) {
84452       {
84453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84454       };
84455     }
84456   }
84457
84458   jresult = (void *)result;
84459   return jresult;
84460 }
84461
84462
84463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84464   void * jresult ;
84465   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84466   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84467
84468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84469   {
84470     try {
84471       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84472     } catch (std::out_of_range& e) {
84473       {
84474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84475       };
84476     } catch (std::exception& e) {
84477       {
84478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84479       };
84480     } catch (Dali::DaliException e) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84483       };
84484     } catch (...) {
84485       {
84486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84487       };
84488     }
84489   }
84490
84491   jresult = (void *)result;
84492   return jresult;
84493 }
84494
84495
84496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84497   void * jresult ;
84498   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84499   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84500
84501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84502   {
84503     try {
84504       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84505     } catch (std::out_of_range& e) {
84506       {
84507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84508       };
84509     } catch (std::exception& e) {
84510       {
84511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84512       };
84513     } catch (Dali::DaliException e) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84516       };
84517     } catch (...) {
84518       {
84519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84520       };
84521     }
84522   }
84523
84524   jresult = (void *)result;
84525   return jresult;
84526 }
84527
84528
84529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84530   void * jresult ;
84531   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84532   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84533
84534   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84535   {
84536     try {
84537       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84545       };
84546     } catch (Dali::DaliException e) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84549       };
84550     } catch (...) {
84551       {
84552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84553       };
84554     }
84555   }
84556
84557   jresult = (void *)result;
84558   return jresult;
84559 }
84560
84561
84562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84563   void * jresult ;
84564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84565   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84566
84567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84568   {
84569     try {
84570       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84571     } catch (std::out_of_range& e) {
84572       {
84573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84574       };
84575     } catch (std::exception& e) {
84576       {
84577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84578       };
84579     } catch (Dali::DaliException e) {
84580       {
84581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84586       };
84587     }
84588   }
84589
84590   jresult = (void *)result;
84591   return jresult;
84592 }
84593
84594
84595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84596   void * jresult ;
84597   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84598   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84599
84600   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84601   {
84602     try {
84603       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84604     } catch (std::out_of_range& e) {
84605       {
84606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84607       };
84608     } catch (std::exception& e) {
84609       {
84610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84611       };
84612     } catch (Dali::DaliException e) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84615       };
84616     } catch (...) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84619       };
84620     }
84621   }
84622
84623   jresult = (void *)result;
84624   return jresult;
84625 }
84626
84627
84628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84629   void * jresult ;
84630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84631   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84632
84633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84634   {
84635     try {
84636       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (Dali::DaliException e) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655
84656   jresult = (void *)result;
84657   return jresult;
84658 }
84659
84660
84661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84662   void * jresult ;
84663   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84664   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84665
84666   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84667   {
84668     try {
84669       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84670     } catch (std::out_of_range& e) {
84671       {
84672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84673       };
84674     } catch (std::exception& e) {
84675       {
84676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84677       };
84678     } catch (Dali::DaliException e) {
84679       {
84680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84681       };
84682     } catch (...) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84685       };
84686     }
84687   }
84688
84689   jresult = (void *)result;
84690   return jresult;
84691 }
84692
84693
84694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84695   void * jresult ;
84696   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84697   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84698
84699   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84700   {
84701     try {
84702       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
84703     } catch (std::out_of_range& e) {
84704       {
84705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84706       };
84707     } catch (std::exception& e) {
84708       {
84709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (Dali::DaliException e) {
84712       {
84713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84714       };
84715     } catch (...) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84718       };
84719     }
84720   }
84721
84722   jresult = (void *)result;
84723   return jresult;
84724 }
84725
84726
84727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
84728   void * jresult ;
84729   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84730   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84731
84732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84733   {
84734     try {
84735       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
84736     } catch (std::out_of_range& e) {
84737       {
84738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84739       };
84740     } catch (std::exception& e) {
84741       {
84742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84743       };
84744     } catch (Dali::DaliException e) {
84745       {
84746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84747       };
84748     } catch (...) {
84749       {
84750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84751       };
84752     }
84753   }
84754
84755   jresult = (void *)result;
84756   return jresult;
84757 }
84758
84759
84760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
84761   void * jresult ;
84762   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84763   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84764
84765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84766   {
84767     try {
84768       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
84769     } catch (std::out_of_range& e) {
84770       {
84771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (std::exception& e) {
84774       {
84775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (Dali::DaliException e) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84780       };
84781     } catch (...) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84784       };
84785     }
84786   }
84787
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
84794   void * jresult ;
84795   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84796   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84797
84798   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84799   {
84800     try {
84801       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
84802     } catch (std::out_of_range& e) {
84803       {
84804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84805       };
84806     } catch (std::exception& e) {
84807       {
84808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (Dali::DaliException e) {
84811       {
84812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84813       };
84814     } catch (...) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84817       };
84818     }
84819   }
84820
84821   jresult = (void *)result;
84822   return jresult;
84823 }
84824
84825
84826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
84827   void * jresult ;
84828   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84829   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84830
84831   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84832   {
84833     try {
84834       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
84835     } catch (std::out_of_range& e) {
84836       {
84837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84838       };
84839     } catch (std::exception& e) {
84840       {
84841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84842       };
84843     } catch (Dali::DaliException e) {
84844       {
84845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84846       };
84847     } catch (...) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84850       };
84851     }
84852   }
84853
84854   jresult = (void *)result;
84855   return jresult;
84856 }
84857
84858
84859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
84860   void * jresult ;
84861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84862   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
84863
84864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84865   {
84866     try {
84867       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
84868     } catch (std::out_of_range& e) {
84869       {
84870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84871       };
84872     } catch (std::exception& e) {
84873       {
84874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84875       };
84876     } catch (Dali::DaliException e) {
84877       {
84878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84879       };
84880     } catch (...) {
84881       {
84882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84883       };
84884     }
84885   }
84886
84887   jresult = (void *)result;
84888   return jresult;
84889 }
84890
84891
84892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
84893   void * jresult ;
84894   Dali::Toolkit::StyleManager *result = 0 ;
84895
84896   {
84897     try {
84898       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
84899     } catch (std::out_of_range& e) {
84900       {
84901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84902       };
84903     } catch (std::exception& e) {
84904       {
84905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84906       };
84907     } catch (Dali::DaliException e) {
84908       {
84909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84910       };
84911     } catch (...) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84914       };
84915     }
84916   }
84917
84918   jresult = (void *)result;
84919   return jresult;
84920 }
84921
84922
84923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
84924   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
84925
84926   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84927   {
84928     try {
84929       delete arg1;
84930     } catch (std::out_of_range& e) {
84931       {
84932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84933       };
84934     } catch (std::exception& e) {
84935       {
84936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84937       };
84938     } catch (Dali::DaliException e) {
84939       {
84940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84941       };
84942     } catch (...) {
84943       {
84944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84945       };
84946     }
84947   }
84948
84949 }
84950
84951
84952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
84953   void * jresult ;
84954   Dali::Toolkit::StyleManager result;
84955
84956   {
84957     try {
84958       result = Dali::Toolkit::StyleManager::Get();
84959     } catch (std::out_of_range& e) {
84960       {
84961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84962       };
84963     } catch (std::exception& e) {
84964       {
84965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (Dali::DaliException e) {
84968       {
84969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84970       };
84971     } catch (...) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84974       };
84975     }
84976   }
84977
84978   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
84979   return jresult;
84980 }
84981
84982
84983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
84984   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
84985   std::string *arg2 = 0 ;
84986
84987   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84988   if (!jarg2) {
84989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84990     return ;
84991   }
84992   std::string arg2_str(jarg2);
84993   arg2 = &arg2_str;
84994   {
84995     try {
84996       (arg1)->ApplyTheme((std::string const &)*arg2);
84997     } catch (std::out_of_range& e) {
84998       {
84999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85000       };
85001     } catch (std::exception& e) {
85002       {
85003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85004       };
85005     } catch (Dali::DaliException e) {
85006       {
85007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85008       };
85009     } catch (...) {
85010       {
85011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85012       };
85013     }
85014   }
85015
85016
85017   //argout typemap for const std::string&
85018
85019 }
85020
85021
85022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85023   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85024
85025   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85026   {
85027     try {
85028       (arg1)->ApplyDefaultTheme();
85029     } catch (std::out_of_range& e) {
85030       {
85031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85032       };
85033     } catch (std::exception& e) {
85034       {
85035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85036       };
85037     } catch (Dali::DaliException e) {
85038       {
85039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85040       };
85041     } catch (...) {
85042       {
85043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85044       };
85045     }
85046   }
85047
85048 }
85049
85050
85051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85052   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85053   std::string *arg2 = 0 ;
85054   Dali::Property::Value *arg3 = 0 ;
85055
85056   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85057   if (!jarg2) {
85058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85059     return ;
85060   }
85061   std::string arg2_str(jarg2);
85062   arg2 = &arg2_str;
85063   arg3 = (Dali::Property::Value *)jarg3;
85064   if (!arg3) {
85065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85066     return ;
85067   }
85068   {
85069     try {
85070       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85071     } catch (std::out_of_range& e) {
85072       {
85073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85074       };
85075     } catch (std::exception& e) {
85076       {
85077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85078       };
85079     } catch (Dali::DaliException e) {
85080       {
85081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85082       };
85083     } catch (...) {
85084       {
85085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85086       };
85087     }
85088   }
85089
85090
85091   //argout typemap for const std::string&
85092
85093 }
85094
85095
85096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85097   unsigned int jresult ;
85098   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85099   std::string *arg2 = 0 ;
85100   Dali::Property::Value *arg3 = 0 ;
85101   bool result;
85102
85103   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85104   if (!jarg2) {
85105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85106     return 0;
85107   }
85108   std::string arg2_str(jarg2);
85109   arg2 = &arg2_str;
85110   arg3 = (Dali::Property::Value *)jarg3;
85111   if (!arg3) {
85112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85113     return 0;
85114   }
85115   {
85116     try {
85117       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85133       };
85134     }
85135   }
85136
85137   jresult = result;
85138
85139   //argout typemap for const std::string&
85140
85141   return jresult;
85142 }
85143
85144
85145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85146   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85147   Dali::Toolkit::Control arg2 ;
85148   std::string *arg3 = 0 ;
85149   std::string *arg4 = 0 ;
85150   Dali::Toolkit::Control *argp2 ;
85151
85152   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85153   argp2 = (Dali::Toolkit::Control *)jarg2;
85154   if (!argp2) {
85155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85156     return ;
85157   }
85158   arg2 = *argp2;
85159   if (!jarg3) {
85160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85161     return ;
85162   }
85163   std::string arg3_str(jarg3);
85164   arg3 = &arg3_str;
85165   if (!jarg4) {
85166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85167     return ;
85168   }
85169   std::string arg4_str(jarg4);
85170   arg4 = &arg4_str;
85171   {
85172     try {
85173       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85174     } catch (std::out_of_range& e) {
85175       {
85176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85177       };
85178     } catch (std::exception& e) {
85179       {
85180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85181       };
85182     } catch (Dali::DaliException e) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85189       };
85190     }
85191   }
85192
85193
85194   //argout typemap for const std::string&
85195
85196
85197   //argout typemap for const std::string&
85198
85199 }
85200
85201
85202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85203   void * jresult ;
85204   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85205   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85206
85207   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85208   {
85209     try {
85210       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85211     } catch (std::out_of_range& e) {
85212       {
85213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85214       };
85215     } catch (std::exception& e) {
85216       {
85217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85218       };
85219     } catch (Dali::DaliException e) {
85220       {
85221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85222       };
85223     } catch (...) {
85224       {
85225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85226       };
85227     }
85228   }
85229
85230   jresult = (void *)result;
85231   return jresult;
85232 }
85233
85234
85235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85236   int jresult ;
85237   int result;
85238
85239   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85240   jresult = (int)result;
85241   return jresult;
85242 }
85243
85244
85245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85246   int jresult ;
85247   int result;
85248
85249   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85250   jresult = (int)result;
85251   return jresult;
85252 }
85253
85254
85255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85256   int jresult ;
85257   int result;
85258
85259   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85260   jresult = (int)result;
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85266   int jresult ;
85267   int result;
85268
85269   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85270   jresult = (int)result;
85271   return jresult;
85272 }
85273
85274
85275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85276   int jresult ;
85277   int result;
85278
85279   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85280   jresult = (int)result;
85281   return jresult;
85282 }
85283
85284
85285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85286   int jresult ;
85287   int result;
85288
85289   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85290   jresult = (int)result;
85291   return jresult;
85292 }
85293
85294
85295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85296   int jresult ;
85297   int result;
85298
85299   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85300   jresult = (int)result;
85301   return jresult;
85302 }
85303
85304
85305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85306   int jresult ;
85307   int result;
85308
85309   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85310   jresult = (int)result;
85311   return jresult;
85312 }
85313
85314
85315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85316   int jresult ;
85317   int result;
85318
85319   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85320   jresult = (int)result;
85321   return jresult;
85322 }
85323
85324
85325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85326   int jresult ;
85327   int result;
85328
85329   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85330   jresult = (int)result;
85331   return jresult;
85332 }
85333
85334
85335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85336   int jresult ;
85337   int result;
85338
85339   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85340   jresult = (int)result;
85341   return jresult;
85342 }
85343
85344
85345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85346   int jresult ;
85347   int result;
85348
85349   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85350   jresult = (int)result;
85351   return jresult;
85352 }
85353
85354
85355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85356   int jresult ;
85357   int result;
85358
85359   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85360   jresult = (int)result;
85361   return jresult;
85362 }
85363
85364
85365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85366   int jresult ;
85367   int result;
85368
85369   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85370   jresult = (int)result;
85371   return jresult;
85372 }
85373
85374
85375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85376   int jresult ;
85377   int result;
85378
85379   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85380   jresult = (int)result;
85381   return jresult;
85382 }
85383
85384
85385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85386   void * jresult ;
85387   Dali::Toolkit::Slider::Property *result = 0 ;
85388
85389   {
85390     try {
85391       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85392     } catch (std::out_of_range& e) {
85393       {
85394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85395       };
85396     } catch (std::exception& e) {
85397       {
85398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85399       };
85400     } catch (Dali::DaliException e) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85403       };
85404     } catch (...) {
85405       {
85406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85407       };
85408     }
85409   }
85410
85411   jresult = (void *)result;
85412   return jresult;
85413 }
85414
85415
85416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85417   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85418
85419   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85420   {
85421     try {
85422       delete arg1;
85423     } catch (std::out_of_range& e) {
85424       {
85425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85426       };
85427     } catch (std::exception& e) {
85428       {
85429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85430       };
85431     } catch (Dali::DaliException e) {
85432       {
85433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85434       };
85435     } catch (...) {
85436       {
85437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85438       };
85439     }
85440   }
85441
85442 }
85443
85444
85445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85446   void * jresult ;
85447   Dali::Toolkit::Slider result;
85448
85449   {
85450     try {
85451       result = Dali::Toolkit::Slider::New();
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (Dali::DaliException e) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85467       };
85468     }
85469   }
85470
85471   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85472   return jresult;
85473 }
85474
85475
85476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85477   void * jresult ;
85478   Dali::Toolkit::Slider *result = 0 ;
85479
85480   {
85481     try {
85482       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85483     } catch (std::out_of_range& e) {
85484       {
85485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85486       };
85487     } catch (std::exception& e) {
85488       {
85489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (Dali::DaliException e) {
85492       {
85493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85494       };
85495     } catch (...) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85498       };
85499     }
85500   }
85501
85502   jresult = (void *)result;
85503   return jresult;
85504 }
85505
85506
85507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85508   void * jresult ;
85509   Dali::Toolkit::Slider *arg1 = 0 ;
85510   Dali::Toolkit::Slider *result = 0 ;
85511
85512   arg1 = (Dali::Toolkit::Slider *)jarg1;
85513   if (!arg1) {
85514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85515     return 0;
85516   }
85517   {
85518     try {
85519       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85520     } catch (std::out_of_range& e) {
85521       {
85522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85523       };
85524     } catch (std::exception& e) {
85525       {
85526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85527       };
85528     } catch (Dali::DaliException e) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85535       };
85536     }
85537   }
85538
85539   jresult = (void *)result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85545   void * jresult ;
85546   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85547   Dali::Toolkit::Slider *arg2 = 0 ;
85548   Dali::Toolkit::Slider *result = 0 ;
85549
85550   arg1 = (Dali::Toolkit::Slider *)jarg1;
85551   arg2 = (Dali::Toolkit::Slider *)jarg2;
85552   if (!arg2) {
85553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85554     return 0;
85555   }
85556   {
85557     try {
85558       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85559     } catch (std::out_of_range& e) {
85560       {
85561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85562       };
85563     } catch (std::exception& e) {
85564       {
85565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85566       };
85567     } catch (Dali::DaliException e) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85570       };
85571     } catch (...) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85574       };
85575     }
85576   }
85577
85578   jresult = (void *)result;
85579   return jresult;
85580 }
85581
85582
85583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85584   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85585
85586   arg1 = (Dali::Toolkit::Slider *)jarg1;
85587   {
85588     try {
85589       delete arg1;
85590     } catch (std::out_of_range& e) {
85591       {
85592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85593       };
85594     } catch (std::exception& e) {
85595       {
85596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85597       };
85598     } catch (Dali::DaliException e) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85601       };
85602     } catch (...) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85605       };
85606     }
85607   }
85608
85609 }
85610
85611
85612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85613   void * jresult ;
85614   Dali::BaseHandle arg1 ;
85615   Dali::BaseHandle *argp1 ;
85616   Dali::Toolkit::Slider result;
85617
85618   argp1 = (Dali::BaseHandle *)jarg1;
85619   if (!argp1) {
85620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85621     return 0;
85622   }
85623   arg1 = *argp1;
85624   {
85625     try {
85626       result = Dali::Toolkit::Slider::DownCast(arg1);
85627     } catch (std::out_of_range& e) {
85628       {
85629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85630       };
85631     } catch (std::exception& e) {
85632       {
85633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85634       };
85635     } catch (Dali::DaliException e) {
85636       {
85637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85638       };
85639     } catch (...) {
85640       {
85641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85642       };
85643     }
85644   }
85645
85646   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85647   return jresult;
85648 }
85649
85650
85651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85652   void * jresult ;
85653   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85654   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85655
85656   arg1 = (Dali::Toolkit::Slider *)jarg1;
85657   {
85658     try {
85659       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85660     } catch (std::out_of_range& e) {
85661       {
85662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85663       };
85664     } catch (std::exception& e) {
85665       {
85666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85667       };
85668     } catch (Dali::DaliException e) {
85669       {
85670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85671       };
85672     } catch (...) {
85673       {
85674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85675       };
85676     }
85677   }
85678
85679   jresult = (void *)result;
85680   return jresult;
85681 }
85682
85683
85684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85685   void * jresult ;
85686   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85687   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85688
85689   arg1 = (Dali::Toolkit::Slider *)jarg1;
85690   {
85691     try {
85692       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85693     } catch (std::out_of_range& e) {
85694       {
85695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85696       };
85697     } catch (std::exception& e) {
85698       {
85699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85700       };
85701     } catch (Dali::DaliException e) {
85702       {
85703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85704       };
85705     } catch (...) {
85706       {
85707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85708       };
85709     }
85710   }
85711
85712   jresult = (void *)result;
85713   return jresult;
85714 }
85715
85716
85717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
85718   void * jresult ;
85719   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85720   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
85721
85722   arg1 = (Dali::Toolkit::Slider *)jarg1;
85723   {
85724     try {
85725       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
85726     } catch (std::out_of_range& e) {
85727       {
85728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85729       };
85730     } catch (std::exception& e) {
85731       {
85732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85733       };
85734     } catch (Dali::DaliException e) {
85735       {
85736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85737       };
85738     } catch (...) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85741       };
85742     }
85743   }
85744
85745   jresult = (void *)result;
85746   return jresult;
85747 }
85748
85749
85750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
85751   int jresult ;
85752   int result;
85753
85754   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
85755   jresult = (int)result;
85756   return jresult;
85757 }
85758
85759
85760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
85761   int jresult ;
85762   int result;
85763
85764   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
85765   jresult = (int)result;
85766   return jresult;
85767 }
85768
85769
85770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
85771   int jresult ;
85772   int result;
85773
85774   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
85775   jresult = (int)result;
85776   return jresult;
85777 }
85778
85779
85780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
85781   int jresult ;
85782   int result;
85783
85784   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
85785   jresult = (int)result;
85786   return jresult;
85787 }
85788
85789
85790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
85791   int result;
85792
85793   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
85794
85795   return result;
85796 }
85797
85798
85799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
85800   void * jresult ;
85801   Dali::Toolkit::VideoView::Property *result = 0 ;
85802
85803   {
85804     try {
85805       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
85806     } catch (std::out_of_range& e) {
85807       {
85808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (std::exception& e) {
85811       {
85812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85813       };
85814     } catch (Dali::DaliException e) {
85815       {
85816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85817       };
85818     } catch (...) {
85819       {
85820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85821       };
85822     }
85823   }
85824
85825   jresult = (void *)result;
85826   return jresult;
85827 }
85828
85829
85830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
85831   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
85832
85833   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
85834   {
85835     try {
85836       delete arg1;
85837     } catch (std::out_of_range& e) {
85838       {
85839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85840       };
85841     } catch (std::exception& e) {
85842       {
85843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85844       };
85845     } catch (Dali::DaliException e) {
85846       {
85847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85848       };
85849     } catch (...) {
85850       {
85851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85852       };
85853     }
85854   }
85855
85856 }
85857
85858
85859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
85860   void * jresult ;
85861   Dali::Toolkit::VideoView result;
85862
85863   {
85864     try {
85865       result = Dali::Toolkit::VideoView::New();
85866     } catch (std::out_of_range& e) {
85867       {
85868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85869       };
85870     } catch (std::exception& e) {
85871       {
85872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85873       };
85874     } catch (Dali::DaliException e) {
85875       {
85876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85877       };
85878     } catch (...) {
85879       {
85880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85881       };
85882     }
85883   }
85884
85885   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
85886   return jresult;
85887 }
85888
85889
85890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
85891   void * jresult ;
85892   std::string *arg1 = 0 ;
85893   Dali::Toolkit::VideoView result;
85894
85895   if (!jarg1) {
85896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85897     return 0;
85898   }
85899   std::string arg1_str(jarg1);
85900   arg1 = &arg1_str;
85901   {
85902     try {
85903       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
85904     } catch (std::out_of_range& e) {
85905       {
85906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85907       };
85908     } catch (std::exception& e) {
85909       {
85910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85911       };
85912     } catch (Dali::DaliException e) {
85913       {
85914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85915       };
85916     } catch (...) {
85917       {
85918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85919       };
85920     }
85921   }
85922
85923   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
85924
85925   //argout typemap for const std::string&
85926
85927   return jresult;
85928 }
85929
85930
85931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
85932   void * jresult ;
85933   Dali::Toolkit::VideoView result;
85934   {
85935     try {
85936       result = Dali::Toolkit::VideoView::New(swCodec);
85937     } catch (std::out_of_range& e) {
85938       {
85939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85940       };
85941     } catch (std::exception& e) {
85942       {
85943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85944       };
85945     } catch (Dali::DaliException e) {
85946       {
85947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85948       };
85949     } catch (...) {
85950       {
85951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85952       };
85953     }
85954   }
85955
85956   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
85957
85958   //argout typemap for const std::string&
85959
85960   return jresult;
85961 }
85962
85963
85964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
85965   void * jresult ;
85966   std::string *arg1 = 0 ;
85967   Dali::Toolkit::VideoView result;
85968
85969   if (!jarg1) {
85970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85971     return 0;
85972   }
85973   std::string arg1_str(jarg1);
85974   arg1 = &arg1_str;
85975   {
85976     try {
85977       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
85978     } catch (std::out_of_range& e) {
85979       {
85980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85981       };
85982     } catch (std::exception& e) {
85983       {
85984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (Dali::DaliException e) {
85987       {
85988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85989       };
85990     } catch (...) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85993       };
85994     }
85995   }
85996
85997   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
85998
85999   //argout typemap for const std::string&
86000
86001   return jresult;
86002 }
86003
86004
86005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86006   void * jresult ;
86007   Dali::Toolkit::VideoView *result = 0 ;
86008
86009   {
86010     try {
86011       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86012     } catch (std::out_of_range& e) {
86013       {
86014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86015       };
86016     } catch (std::exception& e) {
86017       {
86018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86019       };
86020     } catch (Dali::DaliException e) {
86021       {
86022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86023       };
86024     } catch (...) {
86025       {
86026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86027       };
86028     }
86029   }
86030
86031   jresult = (void *)result;
86032   return jresult;
86033 }
86034
86035
86036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86037   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86038
86039   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86040   {
86041     try {
86042       delete arg1;
86043     } catch (std::out_of_range& e) {
86044       {
86045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86046       };
86047     } catch (std::exception& e) {
86048       {
86049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86050       };
86051     } catch (Dali::DaliException e) {
86052       {
86053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86054       };
86055     } catch (...) {
86056       {
86057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86058       };
86059     }
86060   }
86061
86062 }
86063
86064
86065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86066   void * jresult ;
86067   Dali::Toolkit::VideoView *arg1 = 0 ;
86068   Dali::Toolkit::VideoView *result = 0 ;
86069
86070   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86071   if (!arg1) {
86072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86073     return 0;
86074   }
86075   {
86076     try {
86077       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86078     } catch (std::out_of_range& e) {
86079       {
86080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (std::exception& e) {
86083       {
86084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86085       };
86086     } catch (Dali::DaliException e) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86089       };
86090     } catch (...) {
86091       {
86092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86093       };
86094     }
86095   }
86096
86097   jresult = (void *)result;
86098   return jresult;
86099 }
86100
86101
86102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86103   void * jresult ;
86104   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86105   Dali::Toolkit::VideoView *arg2 = 0 ;
86106   Dali::Toolkit::VideoView *result = 0 ;
86107
86108   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86109   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86110   if (!arg2) {
86111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86112     return 0;
86113   }
86114   {
86115     try {
86116       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (Dali::DaliException e) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86128       };
86129     } catch (...) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86132       };
86133     }
86134   }
86135
86136   jresult = (void *)result;
86137   return jresult;
86138 }
86139
86140
86141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86142   void * jresult ;
86143   Dali::BaseHandle arg1 ;
86144   Dali::BaseHandle *argp1 ;
86145   Dali::Toolkit::VideoView result;
86146
86147   argp1 = (Dali::BaseHandle *)jarg1;
86148   if (!argp1) {
86149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86150     return 0;
86151   }
86152   arg1 = *argp1;
86153   {
86154     try {
86155       result = Dali::Toolkit::VideoView::DownCast(arg1);
86156     } catch (std::out_of_range& e) {
86157       {
86158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86159       };
86160     } catch (std::exception& e) {
86161       {
86162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86163       };
86164     } catch (Dali::DaliException e) {
86165       {
86166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86167       };
86168     } catch (...) {
86169       {
86170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86171       };
86172     }
86173   }
86174
86175   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86176   return jresult;
86177 }
86178
86179
86180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86181   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86182
86183   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86184   {
86185     try {
86186       (arg1)->Play();
86187     } catch (std::out_of_range& e) {
86188       {
86189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86190       };
86191     } catch (std::exception& e) {
86192       {
86193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86194       };
86195     } catch (Dali::DaliException e) {
86196       {
86197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86198       };
86199     } catch (...) {
86200       {
86201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86202       };
86203     }
86204   }
86205
86206 }
86207
86208
86209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86210   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86211
86212   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86213   {
86214     try {
86215       (arg1)->Pause();
86216     } catch (std::out_of_range& e) {
86217       {
86218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86219       };
86220     } catch (std::exception& e) {
86221       {
86222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86223       };
86224     } catch (Dali::DaliException e) {
86225       {
86226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86227       };
86228     } catch (...) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86231       };
86232     }
86233   }
86234
86235 }
86236
86237
86238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86239   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86240
86241   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86242   {
86243     try {
86244       (arg1)->Stop();
86245     } catch (std::out_of_range& e) {
86246       {
86247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86248       };
86249     } catch (std::exception& e) {
86250       {
86251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86252       };
86253     } catch (Dali::DaliException e) {
86254       {
86255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86256       };
86257     } catch (...) {
86258       {
86259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86260       };
86261     }
86262   }
86263
86264 }
86265
86266
86267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86268   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86269   int arg2 ;
86270
86271   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86272   arg2 = (int)jarg2;
86273   {
86274     try {
86275       (arg1)->Forward(arg2);
86276     } catch (std::out_of_range& e) {
86277       {
86278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86279       };
86280     } catch (std::exception& e) {
86281       {
86282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86283       };
86284     } catch (Dali::DaliException e) {
86285       {
86286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86287       };
86288     } catch (...) {
86289       {
86290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86291       };
86292     }
86293   }
86294
86295 }
86296
86297
86298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86299   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86300   int arg2 ;
86301
86302   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86303   arg2 = (int)jarg2;
86304   {
86305     try {
86306       (arg1)->Backward(arg2);
86307     } catch (std::out_of_range& e) {
86308       {
86309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86310       };
86311     } catch (std::exception& e) {
86312       {
86313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86314       };
86315     } catch (Dali::DaliException e) {
86316       {
86317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86318       };
86319     } catch (...) {
86320       {
86321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86322       };
86323     }
86324   }
86325
86326 }
86327
86328
86329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86330   void * jresult ;
86331   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86332   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86333
86334   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86335   {
86336     try {
86337       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86338     } catch (std::out_of_range& e) {
86339       {
86340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86341       };
86342     } catch (std::exception& e) {
86343       {
86344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86345       };
86346     } catch (Dali::DaliException e) {
86347       {
86348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86349       };
86350     } catch (...) {
86351       {
86352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86353       };
86354     }
86355   }
86356
86357   jresult = (void *)result;
86358   return jresult;
86359 }
86360
86361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
86362 {
86363   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
86364   if( arg1 == nullptr )
86365   {
86366     DALI_LOG_ERROR("VideoView is nullptr!");
86367     return nullptr;
86368   }
86369   void * ret = nullptr;
86370   {
86371     try{
86372
86373       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
86374       ret = Dali::AnyCast< void * >( result );
86375
86376     } catch (std::out_of_range& e) {
86377       {
86378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86379       };
86380     } catch (std::exception& e) {
86381       {
86382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86383       };
86384     } catch (Dali::DaliException e) {
86385       {
86386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86387       };
86388     } catch (...) {
86389       {
86390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86391       };
86392     }
86393   }
86394   return ret;
86395 }
86396
86397
86398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86399   int jresult ;
86400   int result;
86401
86402   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86403   jresult = (int)result;
86404   return jresult;
86405 }
86406
86407
86408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86409   int jresult ;
86410   int result;
86411
86412   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86413   jresult = (int)result;
86414   return jresult;
86415 }
86416
86417
86418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86419   int jresult ;
86420   int result;
86421
86422   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86423   jresult = (int)result;
86424   return jresult;
86425 }
86426
86427
86428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86429   int jresult ;
86430   int result;
86431
86432   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86433   jresult = (int)result;
86434   return jresult;
86435 }
86436
86437
86438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86439   int jresult ;
86440   int result;
86441
86442   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86443   jresult = (int)result;
86444   return jresult;
86445 }
86446
86447
86448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86449   int jresult ;
86450   int result;
86451
86452   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86453   jresult = (int)result;
86454   return jresult;
86455 }
86456
86457
86458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86459   int jresult ;
86460   int result;
86461
86462   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86463   jresult = (int)result;
86464   return jresult;
86465 }
86466
86467
86468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86469   int jresult ;
86470   int result;
86471
86472   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86473   jresult = (int)result;
86474   return jresult;
86475 }
86476
86477
86478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86479   int jresult ;
86480   int result;
86481
86482   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86483   jresult = (int)result;
86484   return jresult;
86485 }
86486
86487
86488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86489   int jresult ;
86490   int result;
86491
86492   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86493   jresult = (int)result;
86494   return jresult;
86495 }
86496
86497
86498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86499   int jresult ;
86500   int result;
86501
86502   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86503   jresult = (int)result;
86504   return jresult;
86505 }
86506
86507
86508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86509   int jresult ;
86510   int result;
86511
86512   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86513   jresult = (int)result;
86514   return jresult;
86515 }
86516
86517
86518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86519   int jresult ;
86520   int result;
86521
86522   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86523   jresult = (int)result;
86524   return jresult;
86525 }
86526
86527
86528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86529   int jresult ;
86530   int result;
86531
86532   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86533   jresult = (int)result;
86534   return jresult;
86535 }
86536
86537
86538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86539   int jresult ;
86540   int result;
86541
86542   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86543   jresult = (int)result;
86544   return jresult;
86545 }
86546
86547
86548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86549   int jresult ;
86550   int result;
86551
86552   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86553   jresult = (int)result;
86554   return jresult;
86555 }
86556
86557
86558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86559   int jresult ;
86560   int result;
86561
86562   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86563   jresult = (int)result;
86564   return jresult;
86565 }
86566
86567
86568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86569   int jresult ;
86570   int result;
86571
86572   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86573   jresult = (int)result;
86574   return jresult;
86575 }
86576
86577
86578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86579   int jresult ;
86580   int result;
86581
86582   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86583   jresult = (int)result;
86584   return jresult;
86585 }
86586
86587
86588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86589   int jresult ;
86590   int result;
86591
86592   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86593   jresult = (int)result;
86594   return jresult;
86595 }
86596
86597
86598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86599   int jresult ;
86600   int result;
86601
86602   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86603   jresult = (int)result;
86604   return jresult;
86605 }
86606
86607
86608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86609   void * jresult ;
86610   Dali::Toolkit::Popup::Property *result = 0 ;
86611
86612   {
86613     try {
86614       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86615     } catch (std::out_of_range& e) {
86616       {
86617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86618       };
86619     } catch (std::exception& e) {
86620       {
86621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86622       };
86623     } catch (Dali::DaliException e) {
86624       {
86625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86626       };
86627     } catch (...) {
86628       {
86629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86630       };
86631     }
86632   }
86633
86634   jresult = (void *)result;
86635   return jresult;
86636 }
86637
86638
86639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86640   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86641
86642   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86643   {
86644     try {
86645       delete arg1;
86646     } catch (std::out_of_range& e) {
86647       {
86648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86649       };
86650     } catch (std::exception& e) {
86651       {
86652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86653       };
86654     } catch (Dali::DaliException e) {
86655       {
86656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86657       };
86658     } catch (...) {
86659       {
86660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86661       };
86662     }
86663   }
86664
86665 }
86666
86667
86668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86669   void * jresult ;
86670   Dali::Toolkit::Popup *result = 0 ;
86671
86672   {
86673     try {
86674       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86675     } catch (std::out_of_range& e) {
86676       {
86677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86678       };
86679     } catch (std::exception& e) {
86680       {
86681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86682       };
86683     } catch (Dali::DaliException e) {
86684       {
86685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86686       };
86687     } catch (...) {
86688       {
86689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86690       };
86691     }
86692   }
86693
86694   jresult = (void *)result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86700   void * jresult ;
86701   Dali::Toolkit::Popup result;
86702
86703   {
86704     try {
86705       result = Dali::Toolkit::Popup::New();
86706     } catch (std::out_of_range& e) {
86707       {
86708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86709       };
86710     } catch (std::exception& e) {
86711       {
86712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (Dali::DaliException e) {
86715       {
86716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86717       };
86718     } catch (...) {
86719       {
86720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86721       };
86722     }
86723   }
86724
86725   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86726   return jresult;
86727 }
86728
86729
86730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86731   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86732
86733   arg1 = (Dali::Toolkit::Popup *)jarg1;
86734   {
86735     try {
86736       delete arg1;
86737     } catch (std::out_of_range& e) {
86738       {
86739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86740       };
86741     } catch (std::exception& e) {
86742       {
86743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86744       };
86745     } catch (Dali::DaliException e) {
86746       {
86747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86748       };
86749     } catch (...) {
86750       {
86751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86752       };
86753     }
86754   }
86755
86756 }
86757
86758
86759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
86760   void * jresult ;
86761   Dali::Toolkit::Popup *arg1 = 0 ;
86762   Dali::Toolkit::Popup *result = 0 ;
86763
86764   arg1 = (Dali::Toolkit::Popup *)jarg1;
86765   if (!arg1) {
86766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86767     return 0;
86768   }
86769   {
86770     try {
86771       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
86772     } catch (std::out_of_range& e) {
86773       {
86774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (std::exception& e) {
86777       {
86778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86779       };
86780     } catch (Dali::DaliException e) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86783       };
86784     } catch (...) {
86785       {
86786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86787       };
86788     }
86789   }
86790
86791   jresult = (void *)result;
86792   return jresult;
86793 }
86794
86795
86796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
86797   void * jresult ;
86798   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86799   Dali::Toolkit::Popup *arg2 = 0 ;
86800   Dali::Toolkit::Popup *result = 0 ;
86801
86802   arg1 = (Dali::Toolkit::Popup *)jarg1;
86803   arg2 = (Dali::Toolkit::Popup *)jarg2;
86804   if (!arg2) {
86805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86806     return 0;
86807   }
86808   {
86809     try {
86810       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
86811     } catch (std::out_of_range& e) {
86812       {
86813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86814       };
86815     } catch (std::exception& e) {
86816       {
86817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86818       };
86819     } catch (Dali::DaliException e) {
86820       {
86821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86822       };
86823     } catch (...) {
86824       {
86825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86826       };
86827     }
86828   }
86829
86830   jresult = (void *)result;
86831   return jresult;
86832 }
86833
86834
86835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
86836   void * jresult ;
86837   Dali::BaseHandle arg1 ;
86838   Dali::BaseHandle *argp1 ;
86839   Dali::Toolkit::Popup result;
86840
86841   argp1 = (Dali::BaseHandle *)jarg1;
86842   if (!argp1) {
86843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86844     return 0;
86845   }
86846   arg1 = *argp1;
86847   {
86848     try {
86849       result = Dali::Toolkit::Popup::DownCast(arg1);
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (Dali::DaliException e) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86861       };
86862     } catch (...) {
86863       {
86864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86865       };
86866     }
86867   }
86868
86869   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86870   return jresult;
86871 }
86872
86873
86874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
86875   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86876   Dali::Actor arg2 ;
86877   Dali::Actor *argp2 ;
86878
86879   arg1 = (Dali::Toolkit::Popup *)jarg1;
86880   argp2 = (Dali::Actor *)jarg2;
86881   if (!argp2) {
86882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86883     return ;
86884   }
86885   arg2 = *argp2;
86886   {
86887     try {
86888       (arg1)->SetTitle(arg2);
86889     } catch (std::out_of_range& e) {
86890       {
86891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86892       };
86893     } catch (std::exception& e) {
86894       {
86895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86896       };
86897     } catch (Dali::DaliException e) {
86898       {
86899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86900       };
86901     } catch (...) {
86902       {
86903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86904       };
86905     }
86906   }
86907
86908 }
86909
86910
86911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
86912   void * jresult ;
86913   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86914   Dali::Actor result;
86915
86916   arg1 = (Dali::Toolkit::Popup *)jarg1;
86917   {
86918     try {
86919       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
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 = new Dali::Actor((const Dali::Actor &)result);
86940   return jresult;
86941 }
86942
86943
86944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
86945   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86946   Dali::Actor arg2 ;
86947   Dali::Actor *argp2 ;
86948
86949   arg1 = (Dali::Toolkit::Popup *)jarg1;
86950   argp2 = (Dali::Actor *)jarg2;
86951   if (!argp2) {
86952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86953     return ;
86954   }
86955   arg2 = *argp2;
86956   {
86957     try {
86958       (arg1)->SetContent(arg2);
86959     } catch (std::out_of_range& e) {
86960       {
86961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86962       };
86963     } catch (std::exception& e) {
86964       {
86965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86966       };
86967     } catch (Dali::DaliException e) {
86968       {
86969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86970       };
86971     } catch (...) {
86972       {
86973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86974       };
86975     }
86976   }
86977
86978 }
86979
86980
86981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
86982   void * jresult ;
86983   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86984   Dali::Actor result;
86985
86986   arg1 = (Dali::Toolkit::Popup *)jarg1;
86987   {
86988     try {
86989       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
86990     } catch (std::out_of_range& e) {
86991       {
86992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86993       };
86994     } catch (std::exception& e) {
86995       {
86996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86997       };
86998     } catch (Dali::DaliException e) {
86999       {
87000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87001       };
87002     } catch (...) {
87003       {
87004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87005       };
87006     }
87007   }
87008
87009   jresult = new Dali::Actor((const Dali::Actor &)result);
87010   return jresult;
87011 }
87012
87013
87014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87015   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87016   Dali::Actor arg2 ;
87017   Dali::Actor *argp2 ;
87018
87019   arg1 = (Dali::Toolkit::Popup *)jarg1;
87020   argp2 = (Dali::Actor *)jarg2;
87021   if (!argp2) {
87022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87023     return ;
87024   }
87025   arg2 = *argp2;
87026   {
87027     try {
87028       (arg1)->SetFooter(arg2);
87029     } catch (std::out_of_range& e) {
87030       {
87031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87032       };
87033     } catch (std::exception& e) {
87034       {
87035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87036       };
87037     } catch (Dali::DaliException e) {
87038       {
87039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87040       };
87041     } catch (...) {
87042       {
87043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87044       };
87045     }
87046   }
87047
87048 }
87049
87050
87051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87052   void * jresult ;
87053   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87054   Dali::Actor result;
87055
87056   arg1 = (Dali::Toolkit::Popup *)jarg1;
87057   {
87058     try {
87059       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87060     } catch (std::out_of_range& e) {
87061       {
87062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87063       };
87064     } catch (std::exception& e) {
87065       {
87066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87067       };
87068     } catch (Dali::DaliException e) {
87069       {
87070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87075       };
87076     }
87077   }
87078
87079   jresult = new Dali::Actor((const Dali::Actor &)result);
87080   return jresult;
87081 }
87082
87083
87084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87085   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87086   Dali::Toolkit::Popup::DisplayState arg2 ;
87087
87088   arg1 = (Dali::Toolkit::Popup *)jarg1;
87089   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87090   {
87091     try {
87092       (arg1)->SetDisplayState(arg2);
87093     } catch (std::out_of_range& e) {
87094       {
87095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87096       };
87097     } catch (std::exception& e) {
87098       {
87099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87100       };
87101     } catch (Dali::DaliException e) {
87102       {
87103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87104       };
87105     } catch (...) {
87106       {
87107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87108       };
87109     }
87110   }
87111
87112 }
87113
87114
87115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87116   int jresult ;
87117   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87118   Dali::Toolkit::Popup::DisplayState result;
87119
87120   arg1 = (Dali::Toolkit::Popup *)jarg1;
87121   {
87122     try {
87123       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87124     } catch (std::out_of_range& e) {
87125       {
87126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87127       };
87128     } catch (std::exception& e) {
87129       {
87130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87131       };
87132     } catch (Dali::DaliException e) {
87133       {
87134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87135       };
87136     } catch (...) {
87137       {
87138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87139       };
87140     }
87141   }
87142
87143   jresult = (int)result;
87144   return jresult;
87145 }
87146
87147
87148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87149   void * jresult ;
87150   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87151   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87152
87153   arg1 = (Dali::Toolkit::Popup *)jarg1;
87154   {
87155     try {
87156       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87157     } catch (std::out_of_range& e) {
87158       {
87159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87160       };
87161     } catch (std::exception& e) {
87162       {
87163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87164       };
87165     } catch (Dali::DaliException e) {
87166       {
87167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87168       };
87169     } catch (...) {
87170       {
87171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87172       };
87173     }
87174   }
87175
87176   jresult = (void *)result;
87177   return jresult;
87178 }
87179
87180
87181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87182   void * jresult ;
87183   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87184   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87185
87186   arg1 = (Dali::Toolkit::Popup *)jarg1;
87187   {
87188     try {
87189       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87190     } catch (std::out_of_range& e) {
87191       {
87192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87193       };
87194     } catch (std::exception& e) {
87195       {
87196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87197       };
87198     } catch (Dali::DaliException e) {
87199       {
87200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87201       };
87202     } catch (...) {
87203       {
87204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87205       };
87206     }
87207   }
87208
87209   jresult = (void *)result;
87210   return jresult;
87211 }
87212
87213
87214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87215   void * jresult ;
87216   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87217   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87218
87219   arg1 = (Dali::Toolkit::Popup *)jarg1;
87220   {
87221     try {
87222       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87223     } catch (std::out_of_range& e) {
87224       {
87225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87226       };
87227     } catch (std::exception& e) {
87228       {
87229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87230       };
87231     } catch (Dali::DaliException e) {
87232       {
87233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87234       };
87235     } catch (...) {
87236       {
87237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87238       };
87239     }
87240   }
87241
87242   jresult = (void *)result;
87243   return jresult;
87244 }
87245
87246
87247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87248   void * jresult ;
87249   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87250   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87251
87252   arg1 = (Dali::Toolkit::Popup *)jarg1;
87253   {
87254     try {
87255       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87256     } catch (std::out_of_range& e) {
87257       {
87258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (std::exception& e) {
87261       {
87262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (Dali::DaliException e) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87267       };
87268     } catch (...) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87271       };
87272     }
87273   }
87274
87275   jresult = (void *)result;
87276   return jresult;
87277 }
87278
87279
87280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87281   void * jresult ;
87282   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87283   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87284
87285   arg1 = (Dali::Toolkit::Popup *)jarg1;
87286   {
87287     try {
87288       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87289     } catch (std::out_of_range& e) {
87290       {
87291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87292       };
87293     } catch (std::exception& e) {
87294       {
87295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87296       };
87297     } catch (Dali::DaliException e) {
87298       {
87299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87300       };
87301     } catch (...) {
87302       {
87303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87304       };
87305     }
87306   }
87307
87308   jresult = (void *)result;
87309   return jresult;
87310 }
87311
87312
87313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87314   int jresult ;
87315   int result;
87316
87317   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87318   jresult = (int)result;
87319   return jresult;
87320 }
87321
87322
87323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87324   int jresult ;
87325   int result;
87326
87327   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87328   jresult = (int)result;
87329   return jresult;
87330 }
87331
87332
87333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87334   int jresult ;
87335   int result;
87336
87337   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87338   jresult = (int)result;
87339   return jresult;
87340 }
87341
87342
87343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87344   int jresult ;
87345   int result;
87346
87347   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87348   jresult = (int)result;
87349   return jresult;
87350 }
87351
87352
87353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87354   int jresult ;
87355   int result;
87356
87357   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87358   jresult = (int)result;
87359   return jresult;
87360 }
87361
87362
87363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87364   int jresult ;
87365   int result;
87366
87367   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87368   jresult = (int)result;
87369   return jresult;
87370 }
87371
87372
87373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87374   int jresult ;
87375   int result;
87376
87377   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87378   jresult = (int)result;
87379   return jresult;
87380 }
87381
87382
87383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87384   int jresult ;
87385   int result;
87386
87387   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87388   jresult = (int)result;
87389   return jresult;
87390 }
87391
87392
87393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87394   int jresult ;
87395   int result;
87396
87397   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87398   jresult = (int)result;
87399   return jresult;
87400 }
87401
87402
87403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87404   void * jresult ;
87405   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87406
87407   {
87408     try {
87409       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87410     } catch (std::out_of_range& e) {
87411       {
87412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87413       };
87414     } catch (std::exception& e) {
87415       {
87416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87417       };
87418     } catch (Dali::DaliException e) {
87419       {
87420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87421       };
87422     } catch (...) {
87423       {
87424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87425       };
87426     }
87427   }
87428
87429   jresult = (void *)result;
87430   return jresult;
87431 }
87432
87433
87434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87435   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87436
87437   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87438   {
87439     try {
87440       delete arg1;
87441     } catch (std::out_of_range& e) {
87442       {
87443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87444       };
87445     } catch (std::exception& e) {
87446       {
87447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87448       };
87449     } catch (Dali::DaliException e) {
87450       {
87451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87452       };
87453     } catch (...) {
87454       {
87455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87456       };
87457     }
87458   }
87459
87460 }
87461
87462
87463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87464   void * jresult ;
87465   Dali::Toolkit::ProgressBar result;
87466
87467   {
87468     try {
87469       result = Dali::Toolkit::ProgressBar::New();
87470     } catch (std::out_of_range& e) {
87471       {
87472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87473       };
87474     } catch (std::exception& e) {
87475       {
87476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87477       };
87478     } catch (Dali::DaliException e) {
87479       {
87480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87481       };
87482     } catch (...) {
87483       {
87484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87485       };
87486     }
87487   }
87488
87489   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87490   return jresult;
87491 }
87492
87493
87494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87495   void * jresult ;
87496   Dali::Toolkit::ProgressBar *result = 0 ;
87497
87498   {
87499     try {
87500       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87501     } catch (std::out_of_range& e) {
87502       {
87503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87504       };
87505     } catch (std::exception& e) {
87506       {
87507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87508       };
87509     } catch (Dali::DaliException e) {
87510       {
87511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87512       };
87513     } catch (...) {
87514       {
87515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87516       };
87517     }
87518   }
87519
87520   jresult = (void *)result;
87521   return jresult;
87522 }
87523
87524
87525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87526   void * jresult ;
87527   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87528   Dali::Toolkit::ProgressBar *result = 0 ;
87529
87530   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87531   if (!arg1) {
87532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87533     return 0;
87534   }
87535   {
87536     try {
87537       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87538     } catch (std::out_of_range& e) {
87539       {
87540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87541       };
87542     } catch (std::exception& e) {
87543       {
87544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87545       };
87546     } catch (Dali::DaliException e) {
87547       {
87548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87549       };
87550     } catch (...) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87553       };
87554     }
87555   }
87556
87557   jresult = (void *)result;
87558   return jresult;
87559 }
87560
87561
87562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87563   void * jresult ;
87564   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87565   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87566   Dali::Toolkit::ProgressBar *result = 0 ;
87567
87568   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87569   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87570   if (!arg2) {
87571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87572     return 0;
87573   }
87574   {
87575     try {
87576       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87577     } catch (std::out_of_range& e) {
87578       {
87579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87580       };
87581     } catch (std::exception& e) {
87582       {
87583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87584       };
87585     } catch (Dali::DaliException e) {
87586       {
87587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87588       };
87589     } catch (...) {
87590       {
87591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87592       };
87593     }
87594   }
87595
87596   jresult = (void *)result;
87597   return jresult;
87598 }
87599
87600
87601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87602   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87603
87604   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87605   {
87606     try {
87607       delete arg1;
87608     } catch (std::out_of_range& e) {
87609       {
87610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87611       };
87612     } catch (std::exception& e) {
87613       {
87614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87615       };
87616     } catch (Dali::DaliException e) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87619       };
87620     } catch (...) {
87621       {
87622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87623       };
87624     }
87625   }
87626
87627 }
87628
87629
87630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87631   void * jresult ;
87632   Dali::BaseHandle arg1 ;
87633   Dali::BaseHandle *argp1 ;
87634   Dali::Toolkit::ProgressBar result;
87635
87636   argp1 = (Dali::BaseHandle *)jarg1;
87637   if (!argp1) {
87638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87639     return 0;
87640   }
87641   arg1 = *argp1;
87642   {
87643     try {
87644       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87645     } catch (std::out_of_range& e) {
87646       {
87647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87648       };
87649     } catch (std::exception& e) {
87650       {
87651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87652       };
87653     } catch (Dali::DaliException e) {
87654       {
87655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87656       };
87657     } catch (...) {
87658       {
87659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87660       };
87661     }
87662   }
87663
87664   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87665   return jresult;
87666 }
87667
87668
87669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87670   void * jresult ;
87671   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87672   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87673
87674   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87675   {
87676     try {
87677       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87678     } catch (std::out_of_range& e) {
87679       {
87680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87681       };
87682     } catch (std::exception& e) {
87683       {
87684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87685       };
87686     } catch (Dali::DaliException e) {
87687       {
87688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87689       };
87690     } catch (...) {
87691       {
87692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87693       };
87694     }
87695   }
87696
87697   jresult = (void *)result;
87698   return jresult;
87699 }
87700
87701
87702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87703   void * jresult ;
87704   Dali::Toolkit::GaussianBlurView *result = 0 ;
87705
87706   {
87707     try {
87708       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87709     } catch (std::out_of_range& e) {
87710       {
87711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87712       };
87713     } catch (std::exception& e) {
87714       {
87715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87716       };
87717     } catch (Dali::DaliException e) {
87718       {
87719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87720       };
87721     } catch (...) {
87722       {
87723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87724       };
87725     }
87726   }
87727
87728   jresult = (void *)result;
87729   return jresult;
87730 }
87731
87732
87733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87734   void * jresult ;
87735   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
87736   Dali::Toolkit::GaussianBlurView *result = 0 ;
87737
87738   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87739   if (!arg1) {
87740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87741     return 0;
87742   }
87743   {
87744     try {
87745       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
87746     } catch (std::out_of_range& e) {
87747       {
87748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87749       };
87750     } catch (std::exception& e) {
87751       {
87752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87753       };
87754     } catch (Dali::DaliException e) {
87755       {
87756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87757       };
87758     } catch (...) {
87759       {
87760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87761       };
87762     }
87763   }
87764
87765   jresult = (void *)result;
87766   return jresult;
87767 }
87768
87769
87770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
87771   void * jresult ;
87772   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87773   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
87774   Dali::Toolkit::GaussianBlurView *result = 0 ;
87775
87776   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87777   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
87778   if (!arg2) {
87779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87780     return 0;
87781   }
87782   {
87783     try {
87784       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
87785     } catch (std::out_of_range& e) {
87786       {
87787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87788       };
87789     } catch (std::exception& e) {
87790       {
87791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87792       };
87793     } catch (Dali::DaliException e) {
87794       {
87795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87796       };
87797     } catch (...) {
87798       {
87799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87800       };
87801     }
87802   }
87803
87804   jresult = (void *)result;
87805   return jresult;
87806 }
87807
87808
87809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
87810   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87811
87812   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87813   {
87814     try {
87815       delete arg1;
87816     } catch (std::out_of_range& e) {
87817       {
87818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87819       };
87820     } catch (std::exception& e) {
87821       {
87822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87823       };
87824     } catch (Dali::DaliException e) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87827       };
87828     } catch (...) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87831       };
87832     }
87833   }
87834
87835 }
87836
87837
87838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
87839   void * jresult ;
87840   Dali::BaseHandle arg1 ;
87841   Dali::BaseHandle *argp1 ;
87842   Dali::Toolkit::GaussianBlurView result;
87843
87844   argp1 = (Dali::BaseHandle *)jarg1;
87845   if (!argp1) {
87846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87847     return 0;
87848   }
87849   arg1 = *argp1;
87850   {
87851     try {
87852       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
87853     } catch (std::out_of_range& e) {
87854       {
87855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (std::exception& e) {
87858       {
87859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87860       };
87861     } catch (Dali::DaliException e) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87864       };
87865     } catch (...) {
87866       {
87867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87868       };
87869     }
87870   }
87871
87872   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87873   return jresult;
87874 }
87875
87876
87877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
87878   void * jresult ;
87879   Dali::Toolkit::GaussianBlurView result;
87880
87881   {
87882     try {
87883       result = Dali::Toolkit::GaussianBlurView::New();
87884     } catch (std::out_of_range& e) {
87885       {
87886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87887       };
87888     } catch (std::exception& e) {
87889       {
87890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87891       };
87892     } catch (Dali::DaliException e) {
87893       {
87894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87895       };
87896     } catch (...) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87899       };
87900     }
87901   }
87902
87903   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87904   return jresult;
87905 }
87906
87907
87908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
87909   void * jresult ;
87910   unsigned int arg1 ;
87911   float arg2 ;
87912   Dali::Pixel::Format arg3 ;
87913   float arg4 ;
87914   float arg5 ;
87915   bool arg6 ;
87916   Dali::Toolkit::GaussianBlurView result;
87917
87918   arg1 = (unsigned int)jarg1;
87919   arg2 = (float)jarg2;
87920   arg3 = (Dali::Pixel::Format)jarg3;
87921   arg4 = (float)jarg4;
87922   arg5 = (float)jarg5;
87923   arg6 = jarg6 ? true : false;
87924   {
87925     try {
87926       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
87927     } catch (std::out_of_range& e) {
87928       {
87929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87930       };
87931     } catch (std::exception& e) {
87932       {
87933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87934       };
87935     } catch (Dali::DaliException e) {
87936       {
87937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87938       };
87939     } catch (...) {
87940       {
87941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87942       };
87943     }
87944   }
87945
87946   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87947   return jresult;
87948 }
87949
87950
87951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
87952   void * jresult ;
87953   unsigned int arg1 ;
87954   float arg2 ;
87955   Dali::Pixel::Format arg3 ;
87956   float arg4 ;
87957   float arg5 ;
87958   Dali::Toolkit::GaussianBlurView result;
87959
87960   arg1 = (unsigned int)jarg1;
87961   arg2 = (float)jarg2;
87962   arg3 = (Dali::Pixel::Format)jarg3;
87963   arg4 = (float)jarg4;
87964   arg5 = (float)jarg5;
87965   {
87966     try {
87967       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
87968     } catch (std::out_of_range& e) {
87969       {
87970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87971       };
87972     } catch (std::exception& e) {
87973       {
87974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87975       };
87976     } catch (Dali::DaliException e) {
87977       {
87978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87979       };
87980     } catch (...) {
87981       {
87982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87983       };
87984     }
87985   }
87986
87987   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87988   return jresult;
87989 }
87990
87991
87992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
87993   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87994   Dali::Actor arg2 ;
87995   Dali::Actor *argp2 ;
87996
87997   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87998   argp2 = (Dali::Actor *)jarg2;
87999   if (!argp2) {
88000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88001     return ;
88002   }
88003   arg2 = *argp2;
88004   {
88005     try {
88006       (arg1)->Add(arg2);
88007     } catch (std::out_of_range& e) {
88008       {
88009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88010       };
88011     } catch (std::exception& e) {
88012       {
88013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88014       };
88015     } catch (Dali::DaliException e) {
88016       {
88017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88018       };
88019     } catch (...) {
88020       {
88021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88022       };
88023     }
88024   }
88025
88026 }
88027
88028
88029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88030   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88031   Dali::Actor arg2 ;
88032   Dali::Actor *argp2 ;
88033
88034   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88035   argp2 = (Dali::Actor *)jarg2;
88036   if (!argp2) {
88037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88038     return ;
88039   }
88040   arg2 = *argp2;
88041   {
88042     try {
88043       (arg1)->Remove(arg2);
88044     } catch (std::out_of_range& e) {
88045       {
88046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88047       };
88048     } catch (std::exception& e) {
88049       {
88050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88051       };
88052     } catch (Dali::DaliException e) {
88053       {
88054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88055       };
88056     } catch (...) {
88057       {
88058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88059       };
88060     }
88061   }
88062
88063 }
88064
88065
88066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88067   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88068
88069   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88070   {
88071     try {
88072       (arg1)->Activate();
88073     } catch (std::out_of_range& e) {
88074       {
88075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88076       };
88077     } catch (std::exception& e) {
88078       {
88079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88080       };
88081     } catch (Dali::DaliException e) {
88082       {
88083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88084       };
88085     } catch (...) {
88086       {
88087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88088       };
88089     }
88090   }
88091
88092 }
88093
88094
88095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88096   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88097
88098   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88099   {
88100     try {
88101       (arg1)->ActivateOnce();
88102     } catch (std::out_of_range& e) {
88103       {
88104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88105       };
88106     } catch (std::exception& e) {
88107       {
88108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88109       };
88110     } catch (Dali::DaliException e) {
88111       {
88112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88113       };
88114     } catch (...) {
88115       {
88116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88117       };
88118     }
88119   }
88120
88121 }
88122
88123
88124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88125   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88126
88127   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88128   {
88129     try {
88130       (arg1)->Deactivate();
88131     } catch (std::out_of_range& e) {
88132       {
88133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88134       };
88135     } catch (std::exception& e) {
88136       {
88137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88138       };
88139     } catch (Dali::DaliException e) {
88140       {
88141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88142       };
88143     } catch (...) {
88144       {
88145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88146       };
88147     }
88148   }
88149
88150 }
88151
88152
88153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88154   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88155   Dali::Texture arg2 ;
88156   Dali::FrameBuffer arg3 ;
88157   Dali::Texture *argp2 ;
88158   Dali::FrameBuffer *argp3 ;
88159
88160   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88161   argp2 = (Dali::Texture *)jarg2;
88162   if (!argp2) {
88163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88164     return ;
88165   }
88166   arg2 = *argp2;
88167   argp3 = (Dali::FrameBuffer *)jarg3;
88168   if (!argp3) {
88169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88170     return ;
88171   }
88172   arg3 = *argp3;
88173   {
88174     try {
88175       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88176     } catch (std::out_of_range& e) {
88177       {
88178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88179       };
88180     } catch (std::exception& e) {
88181       {
88182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88183       };
88184     } catch (Dali::DaliException e) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88187       };
88188     } catch (...) {
88189       {
88190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88191       };
88192     }
88193   }
88194
88195 }
88196
88197
88198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88199   int jresult ;
88200   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88201   Dali::Property::Index result;
88202
88203   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88204   {
88205     try {
88206       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88207     } catch (std::out_of_range& e) {
88208       {
88209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88210       };
88211     } catch (std::exception& e) {
88212       {
88213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88214       };
88215     } catch (Dali::DaliException e) {
88216       {
88217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88218       };
88219     } catch (...) {
88220       {
88221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88222       };
88223     }
88224   }
88225
88226   jresult = result;
88227   return jresult;
88228 }
88229
88230
88231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88232   void * jresult ;
88233   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88234   Dali::FrameBuffer result;
88235
88236   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88237   {
88238     try {
88239       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88240     } catch (std::out_of_range& e) {
88241       {
88242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88243       };
88244     } catch (std::exception& e) {
88245       {
88246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88247       };
88248     } catch (Dali::DaliException e) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88251       };
88252     } catch (...) {
88253       {
88254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88255       };
88256     }
88257   }
88258
88259   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88260   return jresult;
88261 }
88262
88263
88264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88265   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88266   Dali::Vector4 *arg2 = 0 ;
88267
88268   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88269   arg2 = (Dali::Vector4 *)jarg2;
88270   if (!arg2) {
88271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88272     return ;
88273   }
88274   {
88275     try {
88276       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88292       };
88293     }
88294   }
88295
88296 }
88297
88298
88299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88300   void * jresult ;
88301   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88302   Dali::Vector4 result;
88303
88304   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88305   {
88306     try {
88307       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88308     } catch (std::out_of_range& e) {
88309       {
88310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88311       };
88312     } catch (std::exception& e) {
88313       {
88314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (Dali::DaliException e) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88319       };
88320     } catch (...) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88323       };
88324     }
88325   }
88326
88327   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88328   return jresult;
88329 }
88330
88331
88332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88333   void * jresult ;
88334   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88335   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88336
88337   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88338   {
88339     try {
88340       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88341     } catch (std::out_of_range& e) {
88342       {
88343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88344       };
88345     } catch (std::exception& e) {
88346       {
88347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88348       };
88349     } catch (Dali::DaliException e) {
88350       {
88351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88352       };
88353     } catch (...) {
88354       {
88355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88356       };
88357     }
88358   }
88359
88360   jresult = (void *)result;
88361   return jresult;
88362 }
88363
88364
88365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88366   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88367
88368   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88369   {
88370     try {
88371       delete arg1;
88372     } catch (std::out_of_range& e) {
88373       {
88374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88375       };
88376     } catch (std::exception& e) {
88377       {
88378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88379       };
88380     } catch (Dali::DaliException e) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88383       };
88384     } catch (...) {
88385       {
88386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88387       };
88388     }
88389   }
88390
88391 }
88392
88393
88394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88395   unsigned int jresult ;
88396   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88397   unsigned int result;
88398
88399   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88400   {
88401     try {
88402       result = (unsigned int)(arg1)->GetNumberOfPages();
88403     } catch (std::out_of_range& e) {
88404       {
88405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88406       };
88407     } catch (std::exception& e) {
88408       {
88409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88410       };
88411     } catch (Dali::DaliException e) {
88412       {
88413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88414       };
88415     } catch (...) {
88416       {
88417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88418       };
88419     }
88420   }
88421
88422   jresult = result;
88423   return jresult;
88424 }
88425
88426
88427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88428   void * jresult ;
88429   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88430   unsigned int arg2 ;
88431   Dali::Texture result;
88432
88433   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88434   arg2 = (unsigned int)jarg2;
88435   {
88436     try {
88437       result = (arg1)->NewPage(arg2);
88438     } catch (std::out_of_range& e) {
88439       {
88440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88441       };
88442     } catch (std::exception& e) {
88443       {
88444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88445       };
88446     } catch (Dali::DaliException e) {
88447       {
88448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88449       };
88450     } catch (...) {
88451       {
88452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88453       };
88454     }
88455   }
88456
88457   jresult = new Dali::Texture((const Dali::Texture &)result);
88458   return jresult;
88459 }
88460
88461
88462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88463   int jresult ;
88464   int result;
88465
88466   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88467   jresult = (int)result;
88468   return jresult;
88469 }
88470
88471
88472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88473   int jresult ;
88474   int result;
88475
88476   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88477   jresult = (int)result;
88478   return jresult;
88479 }
88480
88481
88482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88483   int jresult ;
88484   int result;
88485
88486   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88487   jresult = (int)result;
88488   return jresult;
88489 }
88490
88491
88492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88493   void * jresult ;
88494   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88495
88496   {
88497     try {
88498       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88499     } catch (std::out_of_range& e) {
88500       {
88501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88502       };
88503     } catch (std::exception& e) {
88504       {
88505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88506       };
88507     } catch (Dali::DaliException e) {
88508       {
88509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88510       };
88511     } catch (...) {
88512       {
88513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88514       };
88515     }
88516   }
88517
88518   jresult = (void *)result;
88519   return jresult;
88520 }
88521
88522
88523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88524   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88525
88526   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88527   {
88528     try {
88529       delete arg1;
88530     } catch (std::out_of_range& e) {
88531       {
88532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88533       };
88534     } catch (std::exception& e) {
88535       {
88536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88537       };
88538     } catch (Dali::DaliException e) {
88539       {
88540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88541       };
88542     } catch (...) {
88543       {
88544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88545       };
88546     }
88547   }
88548
88549 }
88550
88551
88552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88553   void * jresult ;
88554   Dali::Toolkit::PageTurnView *result = 0 ;
88555
88556   {
88557     try {
88558       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88559     } catch (std::out_of_range& e) {
88560       {
88561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88562       };
88563     } catch (std::exception& e) {
88564       {
88565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88566       };
88567     } catch (Dali::DaliException e) {
88568       {
88569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88570       };
88571     } catch (...) {
88572       {
88573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88574       };
88575     }
88576   }
88577
88578   jresult = (void *)result;
88579   return jresult;
88580 }
88581
88582
88583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88584   void * jresult ;
88585   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88586   Dali::Toolkit::PageTurnView *result = 0 ;
88587
88588   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88589   if (!arg1) {
88590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88591     return 0;
88592   }
88593   {
88594     try {
88595       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88596     } catch (std::out_of_range& e) {
88597       {
88598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88599       };
88600     } catch (std::exception& e) {
88601       {
88602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88603       };
88604     } catch (Dali::DaliException e) {
88605       {
88606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88607       };
88608     } catch (...) {
88609       {
88610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88611       };
88612     }
88613   }
88614
88615   jresult = (void *)result;
88616   return jresult;
88617 }
88618
88619
88620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88621   void * jresult ;
88622   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88623   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88624   Dali::Toolkit::PageTurnView *result = 0 ;
88625
88626   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88627   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88628   if (!arg2) {
88629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88630     return 0;
88631   }
88632   {
88633     try {
88634       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88635     } catch (std::out_of_range& e) {
88636       {
88637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88638       };
88639     } catch (std::exception& e) {
88640       {
88641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88642       };
88643     } catch (Dali::DaliException e) {
88644       {
88645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88646       };
88647     } catch (...) {
88648       {
88649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88650       };
88651     }
88652   }
88653
88654   jresult = (void *)result;
88655   return jresult;
88656 }
88657
88658
88659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88660   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88661
88662   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88663   {
88664     try {
88665       delete arg1;
88666     } catch (std::out_of_range& e) {
88667       {
88668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88669       };
88670     } catch (std::exception& e) {
88671       {
88672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88673       };
88674     } catch (Dali::DaliException e) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88677       };
88678     } catch (...) {
88679       {
88680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88681       };
88682     }
88683   }
88684
88685 }
88686
88687
88688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88689   void * jresult ;
88690   Dali::BaseHandle arg1 ;
88691   Dali::BaseHandle *argp1 ;
88692   Dali::Toolkit::PageTurnView result;
88693
88694   argp1 = (Dali::BaseHandle *)jarg1;
88695   if (!argp1) {
88696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88697     return 0;
88698   }
88699   arg1 = *argp1;
88700   {
88701     try {
88702       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
88703     } catch (std::out_of_range& e) {
88704       {
88705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88706       };
88707     } catch (std::exception& e) {
88708       {
88709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88710       };
88711     } catch (Dali::DaliException e) {
88712       {
88713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88714       };
88715     } catch (...) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88718       };
88719     }
88720   }
88721
88722   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88723   return jresult;
88724 }
88725
88726
88727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88728   void * jresult ;
88729   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88730   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88731
88732   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88733   {
88734     try {
88735       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
88736     } catch (std::out_of_range& e) {
88737       {
88738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (std::exception& e) {
88741       {
88742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88743       };
88744     } catch (Dali::DaliException e) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88751       };
88752     }
88753   }
88754
88755   jresult = (void *)result;
88756   return jresult;
88757 }
88758
88759
88760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
88761   void * jresult ;
88762   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88763   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88764
88765   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88766   {
88767     try {
88768       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
88769     } catch (std::out_of_range& e) {
88770       {
88771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88772       };
88773     } catch (std::exception& e) {
88774       {
88775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88776       };
88777     } catch (Dali::DaliException e) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88780       };
88781     } catch (...) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88784       };
88785     }
88786   }
88787
88788   jresult = (void *)result;
88789   return jresult;
88790 }
88791
88792
88793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
88794   void * jresult ;
88795   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88796   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88797
88798   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88799   {
88800     try {
88801       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
88802     } catch (std::out_of_range& e) {
88803       {
88804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88805       };
88806     } catch (std::exception& e) {
88807       {
88808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88809       };
88810     } catch (Dali::DaliException e) {
88811       {
88812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88813       };
88814     } catch (...) {
88815       {
88816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88817       };
88818     }
88819   }
88820
88821   jresult = (void *)result;
88822   return jresult;
88823 }
88824
88825
88826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
88827   void * jresult ;
88828   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88829   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88830
88831   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88832   {
88833     try {
88834       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
88835     } catch (std::out_of_range& e) {
88836       {
88837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88838       };
88839     } catch (std::exception& e) {
88840       {
88841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88842       };
88843     } catch (Dali::DaliException e) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88846       };
88847     } catch (...) {
88848       {
88849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88850       };
88851     }
88852   }
88853
88854   jresult = (void *)result;
88855   return jresult;
88856 }
88857
88858
88859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
88860   void * jresult ;
88861   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88862
88863   {
88864     try {
88865       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
88866     } catch (std::out_of_range& e) {
88867       {
88868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88869       };
88870     } catch (std::exception& e) {
88871       {
88872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88873       };
88874     } catch (Dali::DaliException e) {
88875       {
88876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88877       };
88878     } catch (...) {
88879       {
88880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88881       };
88882     }
88883   }
88884
88885   jresult = (void *)result;
88886   return jresult;
88887 }
88888
88889
88890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
88891   void * jresult ;
88892   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
88893   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88894
88895   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
88896   if (!arg1) {
88897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
88898     return 0;
88899   }
88900   {
88901     try {
88902       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
88903     } catch (std::out_of_range& e) {
88904       {
88905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (std::exception& e) {
88908       {
88909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88910       };
88911     } catch (Dali::DaliException e) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88914       };
88915     } catch (...) {
88916       {
88917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88918       };
88919     }
88920   }
88921
88922   jresult = (void *)result;
88923   return jresult;
88924 }
88925
88926
88927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
88928   void * jresult ;
88929   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
88930   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
88931   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88932
88933   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
88934   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
88935   if (!arg2) {
88936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
88937     return 0;
88938   }
88939   {
88940     try {
88941       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
88942     } catch (std::out_of_range& e) {
88943       {
88944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (std::exception& e) {
88947       {
88948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88949       };
88950     } catch (Dali::DaliException e) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88953       };
88954     } catch (...) {
88955       {
88956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88957       };
88958     }
88959   }
88960
88961   jresult = (void *)result;
88962   return jresult;
88963 }
88964
88965
88966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
88967   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
88968
88969   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
88970   {
88971     try {
88972       delete arg1;
88973     } catch (std::out_of_range& e) {
88974       {
88975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88976       };
88977     } catch (std::exception& e) {
88978       {
88979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88980       };
88981     } catch (Dali::DaliException e) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88984       };
88985     } catch (...) {
88986       {
88987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88988       };
88989     }
88990   }
88991
88992 }
88993
88994
88995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
88996   void * jresult ;
88997   Dali::Toolkit::PageFactory *arg1 = 0 ;
88998   Dali::Vector2 *arg2 = 0 ;
88999   Dali::Toolkit::PageTurnLandscapeView result;
89000
89001   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89002   if (!arg1) {
89003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89004     return 0;
89005   }
89006   arg2 = (Dali::Vector2 *)jarg2;
89007   if (!arg2) {
89008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89009     return 0;
89010   }
89011   {
89012     try {
89013       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89014     } catch (std::out_of_range& e) {
89015       {
89016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89017       };
89018     } catch (std::exception& e) {
89019       {
89020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89021       };
89022     } catch (Dali::DaliException e) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89025       };
89026     } catch (...) {
89027       {
89028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89029       };
89030     }
89031   }
89032
89033   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89034   return jresult;
89035 }
89036
89037
89038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89039   void * jresult ;
89040   Dali::BaseHandle arg1 ;
89041   Dali::BaseHandle *argp1 ;
89042   Dali::Toolkit::PageTurnLandscapeView result;
89043
89044   argp1 = (Dali::BaseHandle *)jarg1;
89045   if (!argp1) {
89046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89047     return 0;
89048   }
89049   arg1 = *argp1;
89050   {
89051     try {
89052       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89053     } catch (std::out_of_range& e) {
89054       {
89055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89056       };
89057     } catch (std::exception& e) {
89058       {
89059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89060       };
89061     } catch (Dali::DaliException e) {
89062       {
89063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89064       };
89065     } catch (...) {
89066       {
89067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89068       };
89069     }
89070   }
89071
89072   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89073   return jresult;
89074 }
89075
89076
89077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89078   void * jresult ;
89079   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89080
89081   {
89082     try {
89083       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89084     } catch (std::out_of_range& e) {
89085       {
89086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89087       };
89088     } catch (std::exception& e) {
89089       {
89090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89091       };
89092     } catch (Dali::DaliException e) {
89093       {
89094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89095       };
89096     } catch (...) {
89097       {
89098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89099       };
89100     }
89101   }
89102
89103   jresult = (void *)result;
89104   return jresult;
89105 }
89106
89107
89108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89109   void * jresult ;
89110   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89111   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89112
89113   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89114   if (!arg1) {
89115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89116     return 0;
89117   }
89118   {
89119     try {
89120       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89121     } catch (std::out_of_range& e) {
89122       {
89123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89124       };
89125     } catch (std::exception& e) {
89126       {
89127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89128       };
89129     } catch (Dali::DaliException e) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89132       };
89133     } catch (...) {
89134       {
89135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89136       };
89137     }
89138   }
89139
89140   jresult = (void *)result;
89141   return jresult;
89142 }
89143
89144
89145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89146   void * jresult ;
89147   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89148   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89149   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89150
89151   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89152   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89153   if (!arg2) {
89154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89155     return 0;
89156   }
89157   {
89158     try {
89159       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89160     } catch (std::out_of_range& e) {
89161       {
89162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89163       };
89164     } catch (std::exception& e) {
89165       {
89166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89167       };
89168     } catch (Dali::DaliException e) {
89169       {
89170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89175       };
89176     }
89177   }
89178
89179   jresult = (void *)result;
89180   return jresult;
89181 }
89182
89183
89184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89185   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89186
89187   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89188   {
89189     try {
89190       delete arg1;
89191     } catch (std::out_of_range& e) {
89192       {
89193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89194       };
89195     } catch (std::exception& e) {
89196       {
89197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89198       };
89199     } catch (Dali::DaliException e) {
89200       {
89201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89202       };
89203     } catch (...) {
89204       {
89205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89206       };
89207     }
89208   }
89209
89210 }
89211
89212
89213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89214   void * jresult ;
89215   Dali::Toolkit::PageFactory *arg1 = 0 ;
89216   Dali::Vector2 *arg2 = 0 ;
89217   Dali::Toolkit::PageTurnPortraitView result;
89218
89219   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89220   if (!arg1) {
89221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89222     return 0;
89223   }
89224   arg2 = (Dali::Vector2 *)jarg2;
89225   if (!arg2) {
89226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89227     return 0;
89228   }
89229   {
89230     try {
89231       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89232     } catch (std::out_of_range& e) {
89233       {
89234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89235       };
89236     } catch (std::exception& e) {
89237       {
89238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89239       };
89240     } catch (Dali::DaliException e) {
89241       {
89242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89243       };
89244     } catch (...) {
89245       {
89246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89247       };
89248     }
89249   }
89250
89251   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89252   return jresult;
89253 }
89254
89255
89256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89257   void * jresult ;
89258   Dali::BaseHandle arg1 ;
89259   Dali::BaseHandle *argp1 ;
89260   Dali::Toolkit::PageTurnPortraitView result;
89261
89262   argp1 = (Dali::BaseHandle *)jarg1;
89263   if (!argp1) {
89264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89265     return 0;
89266   }
89267   arg1 = *argp1;
89268   {
89269     try {
89270       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89271     } catch (std::out_of_range& e) {
89272       {
89273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89274       };
89275     } catch (std::exception& e) {
89276       {
89277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89278       };
89279     } catch (Dali::DaliException e) {
89280       {
89281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89282       };
89283     } catch (...) {
89284       {
89285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89286       };
89287     }
89288   }
89289
89290   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89291   return jresult;
89292 }
89293
89294
89295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89296   int jresult ;
89297   int result;
89298
89299   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89300   jresult = (int)result;
89301   return jresult;
89302 }
89303
89304
89305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89306   int jresult ;
89307   int result;
89308
89309   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89310   jresult = (int)result;
89311   return jresult;
89312 }
89313
89314
89315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89316   int jresult ;
89317   int result;
89318
89319   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89320   jresult = (int)result;
89321   return jresult;
89322 }
89323
89324
89325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89326   void * jresult ;
89327   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89328
89329   {
89330     try {
89331       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89332     } catch (std::out_of_range& e) {
89333       {
89334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89335       };
89336     } catch (std::exception& e) {
89337       {
89338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89339       };
89340     } catch (Dali::DaliException e) {
89341       {
89342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89343       };
89344     } catch (...) {
89345       {
89346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89347       };
89348     }
89349   }
89350
89351   jresult = (void *)result;
89352   return jresult;
89353 }
89354
89355
89356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89357   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89358
89359   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89360   {
89361     try {
89362       delete arg1;
89363     } catch (std::out_of_range& e) {
89364       {
89365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89366       };
89367     } catch (std::exception& e) {
89368       {
89369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89370       };
89371     } catch (Dali::DaliException e) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89374       };
89375     } catch (...) {
89376       {
89377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89378       };
89379     }
89380   }
89381
89382 }
89383
89384
89385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89386   void * jresult ;
89387   Dali::Toolkit::ToggleButton *result = 0 ;
89388
89389   {
89390     try {
89391       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (Dali::DaliException e) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89403       };
89404     } catch (...) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89407       };
89408     }
89409   }
89410
89411   jresult = (void *)result;
89412   return jresult;
89413 }
89414
89415
89416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89417   void * jresult ;
89418   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89419   Dali::Toolkit::ToggleButton *result = 0 ;
89420
89421   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89422   if (!arg1) {
89423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89424     return 0;
89425   }
89426   {
89427     try {
89428       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89429     } catch (std::out_of_range& e) {
89430       {
89431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89432       };
89433     } catch (std::exception& e) {
89434       {
89435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89436       };
89437     } catch (Dali::DaliException e) {
89438       {
89439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89440       };
89441     } catch (...) {
89442       {
89443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89444       };
89445     }
89446   }
89447
89448   jresult = (void *)result;
89449   return jresult;
89450 }
89451
89452
89453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89454   void * jresult ;
89455   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89456   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89457   Dali::Toolkit::ToggleButton *result = 0 ;
89458
89459   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89460   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89461   if (!arg2) {
89462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89463     return 0;
89464   }
89465   {
89466     try {
89467       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89468     } catch (std::out_of_range& e) {
89469       {
89470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89471       };
89472     } catch (std::exception& e) {
89473       {
89474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89475       };
89476     } catch (Dali::DaliException e) {
89477       {
89478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89479       };
89480     } catch (...) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89483       };
89484     }
89485   }
89486
89487   jresult = (void *)result;
89488   return jresult;
89489 }
89490
89491
89492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89493   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89494
89495   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89496   {
89497     try {
89498       delete arg1;
89499     } catch (std::out_of_range& e) {
89500       {
89501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89502       };
89503     } catch (std::exception& e) {
89504       {
89505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89506       };
89507     } catch (Dali::DaliException e) {
89508       {
89509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89510       };
89511     } catch (...) {
89512       {
89513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89514       };
89515     }
89516   }
89517
89518 }
89519
89520
89521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89522   void * jresult ;
89523   Dali::Toolkit::ToggleButton result;
89524
89525   {
89526     try {
89527       result = Dali::Toolkit::ToggleButton::New();
89528     } catch (std::out_of_range& e) {
89529       {
89530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89531       };
89532     } catch (std::exception& e) {
89533       {
89534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89535       };
89536     } catch (Dali::DaliException e) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89543       };
89544     }
89545   }
89546
89547   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89548   return jresult;
89549 }
89550
89551
89552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89553   void * jresult ;
89554   Dali::BaseHandle arg1 ;
89555   Dali::BaseHandle *argp1 ;
89556   Dali::Toolkit::ToggleButton result;
89557
89558   argp1 = (Dali::BaseHandle *)jarg1;
89559   if (!argp1) {
89560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89561     return 0;
89562   }
89563   arg1 = *argp1;
89564   {
89565     try {
89566       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89567     } catch (std::out_of_range& e) {
89568       {
89569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89570       };
89571     } catch (std::exception& e) {
89572       {
89573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89574       };
89575     } catch (Dali::DaliException e) {
89576       {
89577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89578       };
89579     } catch (...) {
89580       {
89581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89582       };
89583     }
89584   }
89585
89586   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89587   return jresult;
89588 }
89589
89590
89591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89592   void * jresult ;
89593   Dali::Toolkit::Visual::Base *result = 0 ;
89594
89595   {
89596     try {
89597       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89598     } catch (std::out_of_range& e) {
89599       {
89600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (std::exception& e) {
89603       {
89604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89605       };
89606     } catch (Dali::DaliException e) {
89607       {
89608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89609       };
89610     } catch (...) {
89611       {
89612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89613       };
89614     }
89615   }
89616
89617   jresult = (void *)result;
89618   return jresult;
89619 }
89620
89621
89622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89623   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89624
89625   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89626   {
89627     try {
89628       delete arg1;
89629     } catch (std::out_of_range& e) {
89630       {
89631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89632       };
89633     } catch (std::exception& e) {
89634       {
89635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89636       };
89637     } catch (Dali::DaliException e) {
89638       {
89639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89640       };
89641     } catch (...) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89644       };
89645     }
89646   }
89647
89648 }
89649
89650
89651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89652   void * jresult ;
89653   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89654   Dali::Toolkit::Visual::Base *result = 0 ;
89655
89656   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89657   if (!arg1) {
89658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89659     return 0;
89660   }
89661   {
89662     try {
89663       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89671       };
89672     } catch (Dali::DaliException e) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89675       };
89676     } catch (...) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89679       };
89680     }
89681   }
89682
89683   jresult = (void *)result;
89684   return jresult;
89685 }
89686
89687
89688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89689   void * jresult ;
89690   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89691   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89692   Dali::Toolkit::Visual::Base *result = 0 ;
89693
89694   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89695   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89696   if (!arg2) {
89697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89698     return 0;
89699   }
89700   {
89701     try {
89702       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89703     } catch (std::out_of_range& e) {
89704       {
89705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89706       };
89707     } catch (std::exception& e) {
89708       {
89709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89710       };
89711     } catch (Dali::DaliException e) {
89712       {
89713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89714       };
89715     } catch (...) {
89716       {
89717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89718       };
89719     }
89720   }
89721
89722   jresult = (void *)result;
89723   return jresult;
89724 }
89725
89726
89727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89728   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89729   std::string *arg2 = 0 ;
89730
89731   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89732   if (!jarg2) {
89733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89734     return ;
89735   }
89736   std::string arg2_str(jarg2);
89737   arg2 = &arg2_str;
89738   {
89739     try {
89740       (arg1)->SetName((std::string const &)*arg2);
89741     } catch (std::out_of_range& e) {
89742       {
89743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89744       };
89745     } catch (std::exception& e) {
89746       {
89747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89748       };
89749     } catch (Dali::DaliException e) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89752       };
89753     } catch (...) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89756       };
89757     }
89758   }
89759
89760
89761   //argout typemap for const std::string&
89762
89763 }
89764
89765
89766 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
89767   char * jresult ;
89768   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89769   std::string *result = 0 ;
89770
89771   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89772   {
89773     try {
89774       result = (std::string *) &(arg1)->GetName();
89775     } catch (std::out_of_range& e) {
89776       {
89777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89778       };
89779     } catch (std::exception& e) {
89780       {
89781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89782       };
89783     } catch (Dali::DaliException e) {
89784       {
89785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89786       };
89787     } catch (...) {
89788       {
89789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89790       };
89791     }
89792   }
89793
89794   jresult = SWIG_csharp_string_callback(result->c_str());
89795   return jresult;
89796 }
89797
89798
89799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
89800   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89801   Dali::Property::Map *arg2 = 0 ;
89802   Dali::Size arg3 ;
89803   Dali::Size *argp3 ;
89804
89805   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89806   arg2 = (Dali::Property::Map *)jarg2;
89807   if (!arg2) {
89808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89809     return ;
89810   }
89811   argp3 = (Dali::Size *)jarg3;
89812   if (!argp3) {
89813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
89814     return ;
89815   }
89816   arg3 = *argp3;
89817   {
89818     try {
89819       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
89820     } catch (std::out_of_range& e) {
89821       {
89822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89823       };
89824     } catch (std::exception& e) {
89825       {
89826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89827       };
89828     } catch (Dali::DaliException e) {
89829       {
89830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89831       };
89832     } catch (...) {
89833       {
89834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89835       };
89836     }
89837   }
89838
89839 }
89840
89841
89842 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
89843   float jresult ;
89844   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89845   float arg2 ;
89846   float result;
89847
89848   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89849   arg2 = (float)jarg2;
89850   {
89851     try {
89852       result = (float)(arg1)->GetHeightForWidth(arg2);
89853     } catch (std::out_of_range& e) {
89854       {
89855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89856       };
89857     } catch (std::exception& e) {
89858       {
89859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89860       };
89861     } catch (Dali::DaliException e) {
89862       {
89863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89864       };
89865     } catch (...) {
89866       {
89867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89868       };
89869     }
89870   }
89871
89872   jresult = result;
89873   return jresult;
89874 }
89875
89876
89877 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
89878   float jresult ;
89879   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89880   float arg2 ;
89881   float result;
89882
89883   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89884   arg2 = (float)jarg2;
89885   {
89886     try {
89887       result = (float)(arg1)->GetWidthForHeight(arg2);
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89895       };
89896     } catch (Dali::DaliException e) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89903       };
89904     }
89905   }
89906
89907   jresult = result;
89908   return jresult;
89909 }
89910
89911
89912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
89913   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89914   Dali::Vector2 *arg2 = 0 ;
89915
89916   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89917   arg2 = (Dali::Vector2 *)jarg2;
89918   if (!arg2) {
89919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
89920     return ;
89921   }
89922   {
89923     try {
89924       (arg1)->GetNaturalSize(*arg2);
89925     } catch (std::out_of_range& e) {
89926       {
89927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89928       };
89929     } catch (std::exception& e) {
89930       {
89931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89932       };
89933     } catch (Dali::DaliException e) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89936       };
89937     } catch (...) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89940       };
89941     }
89942   }
89943
89944 }
89945
89946
89947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
89948   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89949   float arg2 ;
89950
89951   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89952   arg2 = (int)jarg2;
89953   {
89954     try {
89955       (arg1)->SetDepthIndex(arg2);
89956     } catch (std::out_of_range& e) {
89957       {
89958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89959       };
89960     } catch (std::exception& e) {
89961       {
89962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89963       };
89964     } catch (Dali::DaliException e) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89967       };
89968     } catch (...) {
89969       {
89970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89971       };
89972     }
89973   }
89974
89975 }
89976
89977
89978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
89979   int jresult ;
89980   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89981   int result;
89982
89983   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89984   {
89985     try {
89986       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
89987     } catch (std::out_of_range& e) {
89988       {
89989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89990       };
89991     } catch (std::exception& e) {
89992       {
89993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (Dali::DaliException e) {
89996       {
89997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89998       };
89999     } catch (...) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90002       };
90003     }
90004   }
90005
90006   jresult = result;
90007   return jresult;
90008 }
90009
90010
90011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90012   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90013   Dali::Property::Map *arg2 = 0 ;
90014
90015   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90016   arg2 = (Dali::Property::Map *)jarg2;
90017   if (!arg2) {
90018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90019     return ;
90020   }
90021   {
90022     try {
90023       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90024     } catch (std::out_of_range& e) {
90025       {
90026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90027       };
90028     } catch (std::exception& e) {
90029       {
90030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90031       };
90032     } catch (Dali::DaliException e) {
90033       {
90034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90035       };
90036     } catch (...) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90039       };
90040     }
90041   }
90042
90043 }
90044
90045
90046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90047   void * jresult ;
90048   Dali::Toolkit::VisualFactory result;
90049
90050   {
90051     try {
90052       result = Dali::Toolkit::VisualFactory::Get();
90053     } catch (std::out_of_range& e) {
90054       {
90055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90056       };
90057     } catch (std::exception& e) {
90058       {
90059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90060       };
90061     } catch (Dali::DaliException e) {
90062       {
90063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90064       };
90065     } catch (...) {
90066       {
90067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90068       };
90069     }
90070   }
90071
90072   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90073   return jresult;
90074 }
90075
90076
90077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90078   void * jresult ;
90079   Dali::Toolkit::VisualFactory *result = 0 ;
90080
90081   {
90082     try {
90083       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90091       };
90092     } catch (Dali::DaliException e) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90095       };
90096     } catch (...) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90099       };
90100     }
90101   }
90102
90103   jresult = (void *)result;
90104   return jresult;
90105 }
90106
90107
90108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90109   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90110
90111   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90112   {
90113     try {
90114       delete arg1;
90115     } catch (std::out_of_range& e) {
90116       {
90117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90118       };
90119     } catch (std::exception& e) {
90120       {
90121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90122       };
90123     } catch (Dali::DaliException e) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90126       };
90127     } catch (...) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90130       };
90131     }
90132   }
90133
90134 }
90135
90136
90137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90138   void * jresult ;
90139   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90140   Dali::Toolkit::VisualFactory *result = 0 ;
90141
90142   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90143   if (!arg1) {
90144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90145     return 0;
90146   }
90147   {
90148     try {
90149       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90150     } catch (std::out_of_range& e) {
90151       {
90152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90153       };
90154     } catch (std::exception& e) {
90155       {
90156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90157       };
90158     } catch (Dali::DaliException e) {
90159       {
90160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90161       };
90162     } catch (...) {
90163       {
90164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90165       };
90166     }
90167   }
90168
90169   jresult = (void *)result;
90170   return jresult;
90171 }
90172
90173
90174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90175   void * jresult ;
90176   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90177   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90178   Dali::Toolkit::VisualFactory *result = 0 ;
90179
90180   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90181   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90182   if (!arg2) {
90183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90184     return 0;
90185   }
90186   {
90187     try {
90188       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90189     } catch (std::out_of_range& e) {
90190       {
90191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90192       };
90193     } catch (std::exception& e) {
90194       {
90195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90196       };
90197     } catch (Dali::DaliException e) {
90198       {
90199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90204       };
90205     }
90206   }
90207
90208   jresult = (void *)result;
90209   return jresult;
90210 }
90211
90212
90213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90214   void * jresult ;
90215   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90216   Dali::Property::Map *arg2 = 0 ;
90217   Dali::Toolkit::Visual::Base result;
90218
90219   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90220   arg2 = (Dali::Property::Map *)jarg2;
90221   if (!arg2) {
90222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90223     return 0;
90224   }
90225   {
90226     try {
90227       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90228     } catch (std::out_of_range& e) {
90229       {
90230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90231       };
90232     } catch (std::exception& e) {
90233       {
90234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90235       };
90236     } catch (Dali::DaliException e) {
90237       {
90238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90239       };
90240     } catch (...) {
90241       {
90242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90243       };
90244     }
90245   }
90246
90247   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90248   return jresult;
90249 }
90250
90251
90252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90253   void * jresult ;
90254   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90255   Dali::Image *arg2 = 0 ;
90256   Dali::Toolkit::Visual::Base result;
90257
90258   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90259   arg2 = (Dali::Image *)jarg2;
90260   if (!arg2) {
90261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90262     return 0;
90263   }
90264   {
90265     try {
90266       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
90267     } catch (std::out_of_range& e) {
90268       {
90269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90270       };
90271     } catch (std::exception& e) {
90272       {
90273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90274       };
90275     } catch (Dali::DaliException e) {
90276       {
90277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90278       };
90279     } catch (...) {
90280       {
90281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90282       };
90283     }
90284   }
90285
90286   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90287   return jresult;
90288 }
90289
90290
90291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90292   void * jresult ;
90293   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90294   std::string *arg2 = 0 ;
90295   Dali::ImageDimensions arg3 ;
90296   Dali::ImageDimensions *argp3 ;
90297   Dali::Toolkit::Visual::Base result;
90298
90299   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90300   if (!jarg2) {
90301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90302     return 0;
90303   }
90304   std::string arg2_str(jarg2);
90305   arg2 = &arg2_str;
90306   argp3 = (Dali::ImageDimensions *)jarg3;
90307   if (!argp3) {
90308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90309     return 0;
90310   }
90311   arg3 = *argp3;
90312   {
90313     try {
90314       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90315     } catch (std::out_of_range& e) {
90316       {
90317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90318       };
90319     } catch (std::exception& e) {
90320       {
90321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (Dali::DaliException e) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90330       };
90331     }
90332   }
90333
90334   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90335
90336   //argout typemap for const std::string&
90337
90338   return jresult;
90339 }
90340
90341
90342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90343   void * jresult ;
90344   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90345
90346   {
90347     try {
90348       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90349     } catch (std::out_of_range& e) {
90350       {
90351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90352       };
90353     } catch (std::exception& e) {
90354       {
90355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90356       };
90357     } catch (Dali::DaliException e) {
90358       {
90359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90360       };
90361     } catch (...) {
90362       {
90363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90364       };
90365     }
90366   }
90367
90368   jresult = (void *)result;
90369   return jresult;
90370 }
90371
90372
90373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90374   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90375
90376   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90377   {
90378     try {
90379       delete arg1;
90380     } catch (std::out_of_range& e) {
90381       {
90382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90383       };
90384     } catch (std::exception& e) {
90385       {
90386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90387       };
90388     } catch (Dali::DaliException e) {
90389       {
90390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90391       };
90392     } catch (...) {
90393       {
90394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90395       };
90396     }
90397   }
90398
90399 }
90400
90401
90402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90403   void * jresult ;
90404   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90405   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90406
90407   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90408   if (!arg1) {
90409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90410     return 0;
90411   }
90412   {
90413     try {
90414       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90415     } catch (std::out_of_range& e) {
90416       {
90417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90418       };
90419     } catch (std::exception& e) {
90420       {
90421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90422       };
90423     } catch (Dali::DaliException e) {
90424       {
90425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90426       };
90427     } catch (...) {
90428       {
90429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90430       };
90431     }
90432   }
90433
90434   jresult = (void *)result;
90435   return jresult;
90436 }
90437
90438
90439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90440   void * jresult ;
90441   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90442   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90443   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90444
90445   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90446   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90447   if (!arg2) {
90448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90449     return 0;
90450   }
90451   {
90452     try {
90453       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90454     } catch (std::out_of_range& e) {
90455       {
90456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90457       };
90458     } catch (std::exception& e) {
90459       {
90460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90461       };
90462     } catch (Dali::DaliException e) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90465       };
90466     } catch (...) {
90467       {
90468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90469       };
90470     }
90471   }
90472
90473   jresult = (void *)result;
90474   return jresult;
90475 }
90476
90477
90478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90479   void * jresult ;
90480   Dali::Toolkit::AsyncImageLoader result;
90481
90482   {
90483     try {
90484       result = Dali::Toolkit::AsyncImageLoader::New();
90485     } catch (std::out_of_range& e) {
90486       {
90487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90488       };
90489     } catch (std::exception& e) {
90490       {
90491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90492       };
90493     } catch (Dali::DaliException e) {
90494       {
90495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90496       };
90497     } catch (...) {
90498       {
90499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90500       };
90501     }
90502   }
90503
90504   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90505   return jresult;
90506 }
90507
90508
90509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90510   void * jresult ;
90511   Dali::BaseHandle arg1 ;
90512   Dali::BaseHandle *argp1 ;
90513   Dali::Toolkit::AsyncImageLoader result;
90514
90515   argp1 = (Dali::BaseHandle *)jarg1;
90516   if (!argp1) {
90517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90518     return 0;
90519   }
90520   arg1 = *argp1;
90521   {
90522     try {
90523       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90524     } catch (std::out_of_range& e) {
90525       {
90526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90527       };
90528     } catch (std::exception& e) {
90529       {
90530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90531       };
90532     } catch (Dali::DaliException e) {
90533       {
90534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90535       };
90536     } catch (...) {
90537       {
90538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90539       };
90540     }
90541   }
90542
90543   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90544   return jresult;
90545 }
90546
90547
90548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90549   unsigned int jresult ;
90550   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90551   std::string *arg2 = 0 ;
90552   uint32_t result;
90553
90554   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90555   if (!jarg2) {
90556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90557     return 0;
90558   }
90559   std::string arg2_str(jarg2);
90560   arg2 = &arg2_str;
90561   {
90562     try {
90563       result = (arg1)->Load((std::string const &)*arg2);
90564     } catch (std::out_of_range& e) {
90565       {
90566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90567       };
90568     } catch (std::exception& e) {
90569       {
90570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90571       };
90572     } catch (Dali::DaliException e) {
90573       {
90574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90575       };
90576     } catch (...) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90579       };
90580     }
90581   }
90582
90583   jresult = result;
90584
90585   //argout typemap for const std::string&
90586
90587   return jresult;
90588 }
90589
90590
90591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90592   unsigned int jresult ;
90593   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90594   std::string *arg2 = 0 ;
90595   Dali::ImageDimensions arg3 ;
90596   Dali::ImageDimensions *argp3 ;
90597   uint32_t result;
90598
90599   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90600   if (!jarg2) {
90601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90602     return 0;
90603   }
90604   std::string arg2_str(jarg2);
90605   arg2 = &arg2_str;
90606   argp3 = (Dali::ImageDimensions *)jarg3;
90607   if (!argp3) {
90608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90609     return 0;
90610   }
90611   arg3 = *argp3;
90612   {
90613     try {
90614       result = (arg1)->Load((std::string const &)*arg2,arg3);
90615     } catch (std::out_of_range& e) {
90616       {
90617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90618       };
90619     } catch (std::exception& e) {
90620       {
90621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90622       };
90623     } catch (Dali::DaliException e) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90626       };
90627     } catch (...) {
90628       {
90629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90630       };
90631     }
90632   }
90633
90634   jresult = result;
90635
90636   //argout typemap for const std::string&
90637
90638   return jresult;
90639 }
90640
90641
90642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90643   unsigned int jresult ;
90644   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90645   std::string *arg2 = 0 ;
90646   Dali::ImageDimensions arg3 ;
90647   Dali::FittingMode::Type arg4 ;
90648   Dali::SamplingMode::Type arg5 ;
90649   bool arg6 ;
90650   Dali::ImageDimensions *argp3 ;
90651   uint32_t result;
90652
90653   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90654   if (!jarg2) {
90655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90656     return 0;
90657   }
90658   std::string arg2_str(jarg2);
90659   arg2 = &arg2_str;
90660   argp3 = (Dali::ImageDimensions *)jarg3;
90661   if (!argp3) {
90662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90663     return 0;
90664   }
90665   arg3 = *argp3;
90666   arg4 = (Dali::FittingMode::Type)jarg4;
90667   arg5 = (Dali::SamplingMode::Type)jarg5;
90668   arg6 = jarg6 ? true : false;
90669   {
90670     try {
90671       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90672     } catch (std::out_of_range& e) {
90673       {
90674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90675       };
90676     } catch (std::exception& e) {
90677       {
90678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90679       };
90680     } catch (Dali::DaliException e) {
90681       {
90682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90683       };
90684     } catch (...) {
90685       {
90686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90687       };
90688     }
90689   }
90690
90691   jresult = result;
90692
90693   //argout typemap for const std::string&
90694
90695   return jresult;
90696 }
90697
90698
90699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90700   unsigned int jresult ;
90701   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90702   uint32_t arg2 ;
90703   bool result;
90704
90705   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90706   arg2 = (uint32_t)jarg2;
90707   {
90708     try {
90709       result = (bool)(arg1)->Cancel(arg2);
90710     } catch (std::out_of_range& e) {
90711       {
90712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90713       };
90714     } catch (std::exception& e) {
90715       {
90716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90717       };
90718     } catch (Dali::DaliException e) {
90719       {
90720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90721       };
90722     } catch (...) {
90723       {
90724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90725       };
90726     }
90727   }
90728
90729   jresult = result;
90730   return jresult;
90731 }
90732
90733
90734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90735   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90736
90737   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90738   {
90739     try {
90740       (arg1)->CancelAll();
90741     } catch (std::out_of_range& e) {
90742       {
90743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90744       };
90745     } catch (std::exception& e) {
90746       {
90747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90748       };
90749     } catch (Dali::DaliException e) {
90750       {
90751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90752       };
90753     } catch (...) {
90754       {
90755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90756       };
90757     }
90758   }
90759
90760 }
90761
90762
90763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
90764   void * jresult ;
90765   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90766   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
90767
90768   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90769   {
90770     try {
90771       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
90772     } catch (std::out_of_range& e) {
90773       {
90774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90775       };
90776     } catch (std::exception& e) {
90777       {
90778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90779       };
90780     } catch (Dali::DaliException e) {
90781       {
90782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90783       };
90784     } catch (...) {
90785       {
90786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90787       };
90788     }
90789   }
90790
90791   jresult = (void *)result;
90792   return jresult;
90793 }
90794
90795
90796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
90797   void * jresult ;
90798   std::string *arg1 = 0 ;
90799   Dali::PixelData result;
90800
90801   if (!jarg1) {
90802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90803     return 0;
90804   }
90805   std::string arg1_str(jarg1);
90806   arg1 = &arg1_str;
90807   {
90808     try {
90809       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
90810     } catch (std::out_of_range& e) {
90811       {
90812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90813       };
90814     } catch (std::exception& e) {
90815       {
90816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90817       };
90818     } catch (Dali::DaliException e) {
90819       {
90820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90821       };
90822     } catch (...) {
90823       {
90824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90825       };
90826     }
90827   }
90828
90829   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90830
90831   //argout typemap for const std::string&
90832
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
90838   void * jresult ;
90839   std::string *arg1 = 0 ;
90840   Dali::ImageDimensions arg2 ;
90841   Dali::ImageDimensions *argp2 ;
90842   Dali::PixelData result;
90843
90844   if (!jarg1) {
90845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90846     return 0;
90847   }
90848   std::string arg1_str(jarg1);
90849   arg1 = &arg1_str;
90850   argp2 = (Dali::ImageDimensions *)jarg2;
90851   if (!argp2) {
90852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90853     return 0;
90854   }
90855   arg2 = *argp2;
90856   {
90857     try {
90858       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
90859     } catch (std::out_of_range& e) {
90860       {
90861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90862       };
90863     } catch (std::exception& e) {
90864       {
90865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90866       };
90867     } catch (Dali::DaliException e) {
90868       {
90869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90870       };
90871     } catch (...) {
90872       {
90873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90874       };
90875     }
90876   }
90877
90878   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90879
90880   //argout typemap for const std::string&
90881
90882   return jresult;
90883 }
90884
90885
90886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
90887   void * jresult ;
90888   std::string *arg1 = 0 ;
90889   Dali::ImageDimensions arg2 ;
90890   Dali::FittingMode::Type arg3 ;
90891   Dali::SamplingMode::Type arg4 ;
90892   bool arg5 ;
90893   Dali::ImageDimensions *argp2 ;
90894   Dali::PixelData result;
90895
90896   if (!jarg1) {
90897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90898     return 0;
90899   }
90900   std::string arg1_str(jarg1);
90901   arg1 = &arg1_str;
90902   argp2 = (Dali::ImageDimensions *)jarg2;
90903   if (!argp2) {
90904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90905     return 0;
90906   }
90907   arg2 = *argp2;
90908   arg3 = (Dali::FittingMode::Type)jarg3;
90909   arg4 = (Dali::SamplingMode::Type)jarg4;
90910   arg5 = jarg5 ? true : false;
90911   {
90912     try {
90913       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
90914     } catch (std::out_of_range& e) {
90915       {
90916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90917       };
90918     } catch (std::exception& e) {
90919       {
90920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90921       };
90922     } catch (Dali::DaliException e) {
90923       {
90924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90925       };
90926     } catch (...) {
90927       {
90928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90929       };
90930     }
90931   }
90932
90933   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90934
90935   //argout typemap for const std::string&
90936
90937   return jresult;
90938 }
90939
90940
90941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
90942   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
90943
90944   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
90945   {
90946     try {
90947       delete arg1;
90948     } catch (std::out_of_range& e) {
90949       {
90950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90951       };
90952     } catch (std::exception& e) {
90953       {
90954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90955       };
90956     } catch (Dali::DaliException e) {
90957       {
90958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90959       };
90960     } catch (...) {
90961       {
90962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90963       };
90964     }
90965   }
90966
90967 }
90968
90969
90970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
90971   void * jresult ;
90972   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
90973   Dali::Actor arg2 ;
90974   Dali::Actor arg3 ;
90975   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
90976   Dali::Actor *argp2 ;
90977   Dali::Actor *argp3 ;
90978   Dali::Actor result;
90979
90980   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
90981   argp2 = (Dali::Actor *)jarg2;
90982   if (!argp2) {
90983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90984     return 0;
90985   }
90986   arg2 = *argp2;
90987   argp3 = (Dali::Actor *)jarg3;
90988   if (!argp3) {
90989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90990     return 0;
90991   }
90992   arg3 = *argp3;
90993   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
90994   {
90995     try {
90996       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
90997     } catch (std::out_of_range& e) {
90998       {
90999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91000       };
91001     } catch (std::exception& e) {
91002       {
91003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91004       };
91005     } catch (Dali::DaliException e) {
91006       {
91007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91008       };
91009     } catch (...) {
91010       {
91011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91012       };
91013     }
91014   }
91015
91016   jresult = new Dali::Actor((const Dali::Actor &)result);
91017   return jresult;
91018 }
91019
91020
91021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91022   void * jresult ;
91023   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91024
91025   {
91026     try {
91027       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91028     } catch (std::out_of_range& e) {
91029       {
91030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91031       };
91032     } catch (std::exception& e) {
91033       {
91034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (Dali::DaliException e) {
91037       {
91038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91039       };
91040     } catch (...) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91043       };
91044     }
91045   }
91046
91047   jresult = (void *)result;
91048   return jresult;
91049 }
91050
91051
91052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91053   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91054   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91055   if (director) {
91056     director->swig_connect_director(callback0);
91057   }
91058 }
91059
91060
91061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91062   KeyboardFocusManager arg1 ;
91063   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91064   KeyboardFocusManager *argp1 ;
91065
91066   argp1 = (KeyboardFocusManager *)jarg1;
91067   if (!argp1) {
91068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91069     return ;
91070   }
91071   arg1 = *argp1;
91072   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91073   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91074   {
91075     try {
91076       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91077     } catch (std::out_of_range& e) {
91078       {
91079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91080       };
91081     } catch (std::exception& e) {
91082       {
91083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91084       };
91085     } catch (Dali::DaliException e) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91088       };
91089     } catch (...) {
91090       {
91091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91092       };
91093     }
91094   }
91095
91096 }
91097
91098
91099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91100   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91101
91102   arg1 = (std::vector< unsigned int > *)jarg1;
91103   {
91104     try {
91105       (arg1)->clear();
91106     } catch (std::out_of_range& e) {
91107       {
91108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91109       };
91110     } catch (std::exception& e) {
91111       {
91112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91113       };
91114     } catch (Dali::DaliException e) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91117       };
91118     } catch (...) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91121       };
91122     }
91123   }
91124
91125 }
91126
91127
91128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91129   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91130   unsigned int *arg2 = 0 ;
91131   unsigned int temp2 ;
91132
91133   arg1 = (std::vector< unsigned int > *)jarg1;
91134   temp2 = (unsigned int)jarg2;
91135   arg2 = &temp2;
91136   {
91137     try {
91138       (arg1)->push_back((unsigned int const &)*arg2);
91139     } catch (std::out_of_range& e) {
91140       {
91141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91142       };
91143     } catch (std::exception& e) {
91144       {
91145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91146       };
91147     } catch (Dali::DaliException e) {
91148       {
91149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91150       };
91151     } catch (...) {
91152       {
91153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91154       };
91155     }
91156   }
91157
91158 }
91159
91160
91161 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91162   unsigned long jresult ;
91163   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91164   std::vector< unsigned int >::size_type result;
91165
91166   arg1 = (std::vector< unsigned int > *)jarg1;
91167   {
91168     try {
91169       result = ((std::vector< unsigned int > const *)arg1)->size();
91170     } catch (std::out_of_range& e) {
91171       {
91172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91173       };
91174     } catch (std::exception& e) {
91175       {
91176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91177       };
91178     } catch (Dali::DaliException e) {
91179       {
91180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91181       };
91182     } catch (...) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91185       };
91186     }
91187   }
91188
91189   jresult = (unsigned long)result;
91190   return jresult;
91191 }
91192
91193
91194 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91195   unsigned long jresult ;
91196   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91197   std::vector< unsigned int >::size_type result;
91198
91199   arg1 = (std::vector< unsigned int > *)jarg1;
91200   {
91201     try {
91202       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91203     } catch (std::out_of_range& e) {
91204       {
91205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91206       };
91207     } catch (std::exception& e) {
91208       {
91209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (Dali::DaliException e) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91214       };
91215     } catch (...) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91218       };
91219     }
91220   }
91221
91222   jresult = (unsigned long)result;
91223   return jresult;
91224 }
91225
91226
91227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91228   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91229   std::vector< unsigned int >::size_type arg2 ;
91230
91231   arg1 = (std::vector< unsigned int > *)jarg1;
91232   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91233   {
91234     try {
91235       (arg1)->reserve(arg2);
91236     } catch (std::out_of_range& e) {
91237       {
91238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91239       };
91240     } catch (std::exception& e) {
91241       {
91242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91243       };
91244     } catch (Dali::DaliException e) {
91245       {
91246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91247       };
91248     } catch (...) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91251       };
91252     }
91253   }
91254
91255 }
91256
91257
91258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91259   void * jresult ;
91260   std::vector< unsigned int > *result = 0 ;
91261
91262   {
91263     try {
91264       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91265     } catch (std::out_of_range& e) {
91266       {
91267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91268       };
91269     } catch (std::exception& e) {
91270       {
91271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91272       };
91273     } catch (Dali::DaliException e) {
91274       {
91275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91276       };
91277     } catch (...) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91280       };
91281     }
91282   }
91283
91284   jresult = (void *)result;
91285   return jresult;
91286 }
91287
91288
91289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91290   void * jresult ;
91291   std::vector< unsigned int > *arg1 = 0 ;
91292   std::vector< unsigned int > *result = 0 ;
91293
91294   arg1 = (std::vector< unsigned int > *)jarg1;
91295   if (!arg1) {
91296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91297     return 0;
91298   }
91299   {
91300     try {
91301       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
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 = (void *)result;
91322   return jresult;
91323 }
91324
91325
91326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91327   void * jresult ;
91328   int arg1 ;
91329   std::vector< unsigned int > *result = 0 ;
91330
91331   arg1 = (int)jarg1;
91332   {
91333     try {
91334       try {
91335         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91336       }
91337       catch(std::out_of_range &_e) {
91338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91339         return 0;
91340       }
91341
91342     } catch (std::out_of_range& e) {
91343       {
91344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91345       };
91346     } catch (std::exception& e) {
91347       {
91348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91349       };
91350     } catch (Dali::DaliException e) {
91351       {
91352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91353       };
91354     } catch (...) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91357       };
91358     }
91359   }
91360
91361   jresult = (void *)result;
91362   return jresult;
91363 }
91364
91365
91366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91367   unsigned int jresult ;
91368   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91369   int arg2 ;
91370   unsigned int result;
91371
91372   arg1 = (std::vector< unsigned int > *)jarg1;
91373   arg2 = (int)jarg2;
91374   {
91375     try {
91376       try {
91377         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91378       }
91379       catch(std::out_of_range &_e) {
91380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91381         return 0;
91382       }
91383
91384     } catch (std::out_of_range& e) {
91385       {
91386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91387       };
91388     } catch (std::exception& e) {
91389       {
91390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91391       };
91392     } catch (Dali::DaliException e) {
91393       {
91394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91395       };
91396     } catch (...) {
91397       {
91398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91399       };
91400     }
91401   }
91402
91403   jresult = result;
91404   return jresult;
91405 }
91406
91407
91408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91409   unsigned int jresult ;
91410   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91411   int arg2 ;
91412   unsigned int *result = 0 ;
91413
91414   arg1 = (std::vector< unsigned int > *)jarg1;
91415   arg2 = (int)jarg2;
91416   {
91417     try {
91418       try {
91419         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91420       }
91421       catch(std::out_of_range &_e) {
91422         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91423         return 0;
91424       }
91425
91426     } catch (std::out_of_range& e) {
91427       {
91428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91429       };
91430     } catch (std::exception& e) {
91431       {
91432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91433       };
91434     } catch (Dali::DaliException e) {
91435       {
91436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91437       };
91438     } catch (...) {
91439       {
91440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91441       };
91442     }
91443   }
91444
91445   jresult = *result;
91446   return jresult;
91447 }
91448
91449
91450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91451   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91452   int arg2 ;
91453   unsigned int *arg3 = 0 ;
91454   unsigned int temp3 ;
91455
91456   arg1 = (std::vector< unsigned int > *)jarg1;
91457   arg2 = (int)jarg2;
91458   temp3 = (unsigned int)jarg3;
91459   arg3 = &temp3;
91460   {
91461     try {
91462       try {
91463         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91464       }
91465       catch(std::out_of_range &_e) {
91466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91467         return ;
91468       }
91469
91470     } catch (std::out_of_range& e) {
91471       {
91472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91473       };
91474     } catch (std::exception& e) {
91475       {
91476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91477       };
91478     } catch (Dali::DaliException e) {
91479       {
91480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91481       };
91482     } catch (...) {
91483       {
91484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91485       };
91486     }
91487   }
91488
91489 }
91490
91491
91492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91493   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91494   std::vector< unsigned int > *arg2 = 0 ;
91495
91496   arg1 = (std::vector< unsigned int > *)jarg1;
91497   arg2 = (std::vector< unsigned int > *)jarg2;
91498   if (!arg2) {
91499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91500     return ;
91501   }
91502   {
91503     try {
91504       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91505     } catch (std::out_of_range& e) {
91506       {
91507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91508       };
91509     } catch (std::exception& e) {
91510       {
91511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91512       };
91513     } catch (Dali::DaliException e) {
91514       {
91515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91516       };
91517     } catch (...) {
91518       {
91519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91520       };
91521     }
91522   }
91523
91524 }
91525
91526
91527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91528   void * jresult ;
91529   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91530   int arg2 ;
91531   int arg3 ;
91532   std::vector< unsigned int > *result = 0 ;
91533
91534   arg1 = (std::vector< unsigned int > *)jarg1;
91535   arg2 = (int)jarg2;
91536   arg3 = (int)jarg3;
91537   {
91538     try {
91539       try {
91540         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91541       }
91542       catch(std::out_of_range &_e) {
91543         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91544         return 0;
91545       }
91546       catch(std::invalid_argument &_e) {
91547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91548         return 0;
91549       }
91550
91551     } catch (std::out_of_range& e) {
91552       {
91553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91554       };
91555     } catch (std::exception& e) {
91556       {
91557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91558       };
91559     } catch (Dali::DaliException e) {
91560       {
91561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91562       };
91563     } catch (...) {
91564       {
91565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91566       };
91567     }
91568   }
91569
91570   jresult = (void *)result;
91571   return jresult;
91572 }
91573
91574
91575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91576   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91577   int arg2 ;
91578   unsigned int *arg3 = 0 ;
91579   unsigned int temp3 ;
91580
91581   arg1 = (std::vector< unsigned int > *)jarg1;
91582   arg2 = (int)jarg2;
91583   temp3 = (unsigned int)jarg3;
91584   arg3 = &temp3;
91585   {
91586     try {
91587       try {
91588         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91589       }
91590       catch(std::out_of_range &_e) {
91591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91592         return ;
91593       }
91594
91595     } catch (std::out_of_range& e) {
91596       {
91597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91598       };
91599     } catch (std::exception& e) {
91600       {
91601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91602       };
91603     } catch (Dali::DaliException e) {
91604       {
91605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91606       };
91607     } catch (...) {
91608       {
91609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91610       };
91611     }
91612   }
91613
91614 }
91615
91616
91617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91618   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91619   int arg2 ;
91620   std::vector< unsigned int > *arg3 = 0 ;
91621
91622   arg1 = (std::vector< unsigned int > *)jarg1;
91623   arg2 = (int)jarg2;
91624   arg3 = (std::vector< unsigned int > *)jarg3;
91625   if (!arg3) {
91626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91627     return ;
91628   }
91629   {
91630     try {
91631       try {
91632         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91633       }
91634       catch(std::out_of_range &_e) {
91635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91636         return ;
91637       }
91638
91639     } catch (std::out_of_range& e) {
91640       {
91641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91642       };
91643     } catch (std::exception& e) {
91644       {
91645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91646       };
91647     } catch (Dali::DaliException e) {
91648       {
91649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91650       };
91651     } catch (...) {
91652       {
91653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91654       };
91655     }
91656   }
91657
91658 }
91659
91660
91661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91662   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91663   int arg2 ;
91664
91665   arg1 = (std::vector< unsigned int > *)jarg1;
91666   arg2 = (int)jarg2;
91667   {
91668     try {
91669       try {
91670         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91671       }
91672       catch(std::out_of_range &_e) {
91673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91674         return ;
91675       }
91676
91677     } catch (std::out_of_range& e) {
91678       {
91679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91680       };
91681     } catch (std::exception& e) {
91682       {
91683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91684       };
91685     } catch (Dali::DaliException e) {
91686       {
91687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91688       };
91689     } catch (...) {
91690       {
91691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91692       };
91693     }
91694   }
91695
91696 }
91697
91698
91699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91700   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91701   int arg2 ;
91702   int arg3 ;
91703
91704   arg1 = (std::vector< unsigned int > *)jarg1;
91705   arg2 = (int)jarg2;
91706   arg3 = (int)jarg3;
91707   {
91708     try {
91709       try {
91710         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91711       }
91712       catch(std::out_of_range &_e) {
91713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91714         return ;
91715       }
91716       catch(std::invalid_argument &_e) {
91717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91718         return ;
91719       }
91720
91721     } catch (std::out_of_range& e) {
91722       {
91723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91724       };
91725     } catch (std::exception& e) {
91726       {
91727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91728       };
91729     } catch (Dali::DaliException e) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91736       };
91737     }
91738   }
91739
91740 }
91741
91742
91743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
91744   void * jresult ;
91745   unsigned int *arg1 = 0 ;
91746   int arg2 ;
91747   unsigned int temp1 ;
91748   std::vector< unsigned int > *result = 0 ;
91749
91750   temp1 = (unsigned int)jarg1;
91751   arg1 = &temp1;
91752   arg2 = (int)jarg2;
91753   {
91754     try {
91755       try {
91756         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
91757       }
91758       catch(std::out_of_range &_e) {
91759         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91760         return 0;
91761       }
91762
91763     } catch (std::out_of_range& e) {
91764       {
91765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91766       };
91767     } catch (std::exception& e) {
91768       {
91769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91770       };
91771     } catch (Dali::DaliException e) {
91772       {
91773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91774       };
91775     } catch (...) {
91776       {
91777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91778       };
91779     }
91780   }
91781
91782   jresult = (void *)result;
91783   return jresult;
91784 }
91785
91786
91787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
91788   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91789
91790   arg1 = (std::vector< unsigned int > *)jarg1;
91791   {
91792     try {
91793       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
91794     } catch (std::out_of_range& e) {
91795       {
91796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91797       };
91798     } catch (std::exception& e) {
91799       {
91800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91801       };
91802     } catch (Dali::DaliException e) {
91803       {
91804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91805       };
91806     } catch (...) {
91807       {
91808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91809       };
91810     }
91811   }
91812
91813 }
91814
91815
91816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91817   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91818   int arg2 ;
91819   int arg3 ;
91820
91821   arg1 = (std::vector< unsigned int > *)jarg1;
91822   arg2 = (int)jarg2;
91823   arg3 = (int)jarg3;
91824   {
91825     try {
91826       try {
91827         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91828       }
91829       catch(std::out_of_range &_e) {
91830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91831         return ;
91832       }
91833       catch(std::invalid_argument &_e) {
91834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91835         return ;
91836       }
91837
91838     } catch (std::out_of_range& e) {
91839       {
91840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91841       };
91842     } catch (std::exception& e) {
91843       {
91844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91845       };
91846     } catch (Dali::DaliException e) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91849       };
91850     } catch (...) {
91851       {
91852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91853       };
91854     }
91855   }
91856
91857 }
91858
91859
91860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91861   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91862   int arg2 ;
91863   std::vector< unsigned int > *arg3 = 0 ;
91864
91865   arg1 = (std::vector< unsigned int > *)jarg1;
91866   arg2 = (int)jarg2;
91867   arg3 = (std::vector< unsigned int > *)jarg3;
91868   if (!arg3) {
91869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91870     return ;
91871   }
91872   {
91873     try {
91874       try {
91875         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91876       }
91877       catch(std::out_of_range &_e) {
91878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91879         return ;
91880       }
91881
91882     } catch (std::out_of_range& e) {
91883       {
91884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91885       };
91886     } catch (std::exception& e) {
91887       {
91888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91889       };
91890     } catch (Dali::DaliException e) {
91891       {
91892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91893       };
91894     } catch (...) {
91895       {
91896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91897       };
91898     }
91899   }
91900
91901 }
91902
91903
91904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
91905   unsigned int jresult ;
91906   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91907   unsigned int *arg2 = 0 ;
91908   unsigned int temp2 ;
91909   bool result;
91910
91911   arg1 = (std::vector< unsigned int > *)jarg1;
91912   temp2 = (unsigned int)jarg2;
91913   arg2 = &temp2;
91914   {
91915     try {
91916       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
91917     } catch (std::out_of_range& e) {
91918       {
91919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91920       };
91921     } catch (std::exception& e) {
91922       {
91923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91924       };
91925     } catch (Dali::DaliException e) {
91926       {
91927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91928       };
91929     } catch (...) {
91930       {
91931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91932       };
91933     }
91934   }
91935
91936   jresult = result;
91937   return jresult;
91938 }
91939
91940
91941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
91942   int jresult ;
91943   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91944   unsigned int *arg2 = 0 ;
91945   unsigned int temp2 ;
91946   int result;
91947
91948   arg1 = (std::vector< unsigned int > *)jarg1;
91949   temp2 = (unsigned int)jarg2;
91950   arg2 = &temp2;
91951   {
91952     try {
91953       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
91954     } catch (std::out_of_range& e) {
91955       {
91956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91957       };
91958     } catch (std::exception& e) {
91959       {
91960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91961       };
91962     } catch (Dali::DaliException e) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91965       };
91966     } catch (...) {
91967       {
91968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91969       };
91970     }
91971   }
91972
91973   jresult = result;
91974   return jresult;
91975 }
91976
91977
91978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
91979   int jresult ;
91980   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91981   unsigned int *arg2 = 0 ;
91982   unsigned int temp2 ;
91983   int result;
91984
91985   arg1 = (std::vector< unsigned int > *)jarg1;
91986   temp2 = (unsigned int)jarg2;
91987   arg2 = &temp2;
91988   {
91989     try {
91990       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
91991     } catch (std::out_of_range& e) {
91992       {
91993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91994       };
91995     } catch (std::exception& e) {
91996       {
91997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (Dali::DaliException e) {
92000       {
92001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92002       };
92003     } catch (...) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92006       };
92007     }
92008   }
92009
92010   jresult = result;
92011   return jresult;
92012 }
92013
92014
92015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92016   unsigned int jresult ;
92017   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92018   unsigned int *arg2 = 0 ;
92019   unsigned int temp2 ;
92020   bool result;
92021
92022   arg1 = (std::vector< unsigned int > *)jarg1;
92023   temp2 = (unsigned int)jarg2;
92024   arg2 = &temp2;
92025   {
92026     try {
92027       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92028     } catch (std::out_of_range& e) {
92029       {
92030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92031       };
92032     } catch (std::exception& e) {
92033       {
92034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92035       };
92036     } catch (Dali::DaliException e) {
92037       {
92038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92039       };
92040     } catch (...) {
92041       {
92042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92043       };
92044     }
92045   }
92046
92047   jresult = result;
92048   return jresult;
92049 }
92050
92051
92052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92053   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92054
92055   arg1 = (std::vector< unsigned int > *)jarg1;
92056   {
92057     try {
92058       delete arg1;
92059     } catch (std::out_of_range& e) {
92060       {
92061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92062       };
92063     } catch (std::exception& e) {
92064       {
92065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92066       };
92067     } catch (Dali::DaliException e) {
92068       {
92069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92070       };
92071     } catch (...) {
92072       {
92073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92074       };
92075     }
92076   }
92077
92078 }
92079
92080
92081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92082   void * jresult ;
92083   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92084
92085   {
92086     try {
92087       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92088     } catch (std::out_of_range& e) {
92089       {
92090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92091       };
92092     } catch (std::exception& e) {
92093       {
92094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92095       };
92096     } catch (Dali::DaliException e) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92099       };
92100     } catch (...) {
92101       {
92102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92103       };
92104     }
92105   }
92106
92107   jresult = (void *)result;
92108   return jresult;
92109 }
92110
92111
92112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92113   void * jresult ;
92114   unsigned int arg1 ;
92115   Dali::Actor arg2 ;
92116   Dali::Actor *argp2 ;
92117   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92118
92119   arg1 = (unsigned int)jarg1;
92120   argp2 = (Dali::Actor *)jarg2;
92121   if (!argp2) {
92122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92123     return 0;
92124   }
92125   arg2 = *argp2;
92126   {
92127     try {
92128       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92129     } catch (std::out_of_range& e) {
92130       {
92131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92132       };
92133     } catch (std::exception& e) {
92134       {
92135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92136       };
92137     } catch (Dali::DaliException e) {
92138       {
92139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92140       };
92141     } catch (...) {
92142       {
92143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92144       };
92145     }
92146   }
92147
92148   jresult = (void *)result;
92149   return jresult;
92150 }
92151
92152
92153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92154   void * jresult ;
92155   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92156   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92157
92158   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92159   if (!arg1) {
92160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92161     return 0;
92162   }
92163   {
92164     try {
92165       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92166     } catch (std::out_of_range& e) {
92167       {
92168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92169       };
92170     } catch (std::exception& e) {
92171       {
92172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92173       };
92174     } catch (Dali::DaliException e) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92177       };
92178     } catch (...) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92181       };
92182     }
92183   }
92184
92185   jresult = (void *)result;
92186   return jresult;
92187 }
92188
92189
92190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92191   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92192   unsigned int arg2 ;
92193
92194   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92195   arg2 = (unsigned int)jarg2;
92196   if (arg1) (arg1)->first = arg2;
92197 }
92198
92199
92200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92201   unsigned int jresult ;
92202   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92203   unsigned int result;
92204
92205   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92206   result = (unsigned int) ((arg1)->first);
92207   jresult = result;
92208   return jresult;
92209 }
92210
92211
92212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92213   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92214   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92215
92216   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92217   arg2 = (Dali::Actor *)jarg2;
92218   if (arg1) (arg1)->second = *arg2;
92219 }
92220
92221
92222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92223   void * jresult ;
92224   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92225   Dali::Actor *result = 0 ;
92226
92227   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92228   result = (Dali::Actor *)& ((arg1)->second);
92229   jresult = (void *)result;
92230   return jresult;
92231 }
92232
92233
92234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92235   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92236
92237   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92238   {
92239     try {
92240       delete arg1;
92241     } catch (std::out_of_range& e) {
92242       {
92243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92244       };
92245     } catch (std::exception& e) {
92246       {
92247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92248       };
92249     } catch (Dali::DaliException e) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92252       };
92253     } catch (...) {
92254       {
92255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92256       };
92257     }
92258   }
92259
92260 }
92261
92262
92263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92264   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92265
92266   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92267   {
92268     try {
92269       (arg1)->clear();
92270     } catch (std::out_of_range& e) {
92271       {
92272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92273       };
92274     } catch (std::exception& e) {
92275       {
92276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92277       };
92278     } catch (Dali::DaliException e) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92281       };
92282     } catch (...) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92285       };
92286     }
92287   }
92288
92289 }
92290
92291
92292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92293   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92294   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92295
92296   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92297   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92298   if (!arg2) {
92299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92300     return ;
92301   }
92302   {
92303     try {
92304       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92305     } catch (std::out_of_range& e) {
92306       {
92307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92308       };
92309     } catch (std::exception& e) {
92310       {
92311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92312       };
92313     } catch (Dali::DaliException e) {
92314       {
92315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92316       };
92317     } catch (...) {
92318       {
92319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92320       };
92321     }
92322   }
92323
92324 }
92325
92326
92327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92328   unsigned long jresult ;
92329   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92330   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92331
92332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92333   {
92334     try {
92335       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92336     } catch (std::out_of_range& e) {
92337       {
92338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92339       };
92340     } catch (std::exception& e) {
92341       {
92342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (Dali::DaliException e) {
92345       {
92346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92347       };
92348     } catch (...) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92351       };
92352     }
92353   }
92354
92355   jresult = (unsigned long)result;
92356   return jresult;
92357 }
92358
92359
92360 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92361   unsigned long jresult ;
92362   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92363   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92364
92365   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92366   {
92367     try {
92368       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92369     } catch (std::out_of_range& e) {
92370       {
92371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92372       };
92373     } catch (std::exception& e) {
92374       {
92375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92376       };
92377     } catch (Dali::DaliException e) {
92378       {
92379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92380       };
92381     } catch (...) {
92382       {
92383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92384       };
92385     }
92386   }
92387
92388   jresult = (unsigned long)result;
92389   return jresult;
92390 }
92391
92392
92393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92394   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92395   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92396
92397   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92398   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92399   {
92400     try {
92401       (arg1)->reserve(arg2);
92402     } catch (std::out_of_range& e) {
92403       {
92404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92405       };
92406     } catch (std::exception& e) {
92407       {
92408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92409       };
92410     } catch (Dali::DaliException e) {
92411       {
92412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92413       };
92414     } catch (...) {
92415       {
92416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92417       };
92418     }
92419   }
92420
92421 }
92422
92423
92424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92425   void * jresult ;
92426   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92427
92428   {
92429     try {
92430       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92431     } catch (std::out_of_range& e) {
92432       {
92433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92434       };
92435     } catch (std::exception& e) {
92436       {
92437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92438       };
92439     } catch (Dali::DaliException e) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92442       };
92443     } catch (...) {
92444       {
92445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92446       };
92447     }
92448   }
92449
92450   jresult = (void *)result;
92451   return jresult;
92452 }
92453
92454
92455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92456   void * jresult ;
92457   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92458   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92459
92460   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92461   if (!arg1) {
92462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92463     return 0;
92464   }
92465   {
92466     try {
92467       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);
92468     } catch (std::out_of_range& e) {
92469       {
92470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92471       };
92472     } catch (std::exception& e) {
92473       {
92474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (Dali::DaliException e) {
92477       {
92478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92479       };
92480     } catch (...) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92483       };
92484     }
92485   }
92486
92487   jresult = (void *)result;
92488   return jresult;
92489 }
92490
92491
92492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92493   void * jresult ;
92494   int arg1 ;
92495   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92496
92497   arg1 = (int)jarg1;
92498   {
92499     try {
92500       try {
92501         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);
92502       }
92503       catch(std::out_of_range &_e) {
92504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92505         return 0;
92506       }
92507
92508     } catch (std::out_of_range& e) {
92509       {
92510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92511       };
92512     } catch (std::exception& e) {
92513       {
92514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92515       };
92516     } catch (Dali::DaliException e) {
92517       {
92518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92519       };
92520     } catch (...) {
92521       {
92522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92523       };
92524     }
92525   }
92526
92527   jresult = (void *)result;
92528   return jresult;
92529 }
92530
92531
92532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92533   void * jresult ;
92534   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92535   int arg2 ;
92536   std::pair< unsigned int,Dali::Actor > result;
92537
92538   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92539   arg2 = (int)jarg2;
92540   {
92541     try {
92542       try {
92543         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92544       }
92545       catch(std::out_of_range &_e) {
92546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92547         return 0;
92548       }
92549
92550     } catch (std::out_of_range& e) {
92551       {
92552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92553       };
92554     } catch (std::exception& e) {
92555       {
92556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92557       };
92558     } catch (Dali::DaliException e) {
92559       {
92560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92561       };
92562     } catch (...) {
92563       {
92564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92565       };
92566     }
92567   }
92568
92569   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92570   return jresult;
92571 }
92572
92573
92574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92575   void * jresult ;
92576   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92577   int arg2 ;
92578   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92579
92580   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92581   arg2 = (int)jarg2;
92582   {
92583     try {
92584       try {
92585         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92586       }
92587       catch(std::out_of_range &_e) {
92588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92589         return 0;
92590       }
92591
92592     } catch (std::out_of_range& e) {
92593       {
92594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92595       };
92596     } catch (std::exception& e) {
92597       {
92598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92599       };
92600     } catch (Dali::DaliException e) {
92601       {
92602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92603       };
92604     } catch (...) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92607       };
92608     }
92609   }
92610
92611   jresult = (void *)result;
92612   return jresult;
92613 }
92614
92615
92616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92617   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92618   int arg2 ;
92619   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92620
92621   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92622   arg2 = (int)jarg2;
92623   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92624   if (!arg3) {
92625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92626     return ;
92627   }
92628   {
92629     try {
92630       try {
92631         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);
92632       }
92633       catch(std::out_of_range &_e) {
92634         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92635         return ;
92636       }
92637
92638     } catch (std::out_of_range& e) {
92639       {
92640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92641       };
92642     } catch (std::exception& e) {
92643       {
92644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92645       };
92646     } catch (Dali::DaliException e) {
92647       {
92648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92649       };
92650     } catch (...) {
92651       {
92652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92653       };
92654     }
92655   }
92656
92657 }
92658
92659
92660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92661   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92662   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92663
92664   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92665   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92666   if (!arg2) {
92667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92668     return ;
92669   }
92670   {
92671     try {
92672       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);
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92688       };
92689     }
92690   }
92691
92692 }
92693
92694
92695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92696   void * jresult ;
92697   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92698   int arg2 ;
92699   int arg3 ;
92700   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92701
92702   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92703   arg2 = (int)jarg2;
92704   arg3 = (int)jarg3;
92705   {
92706     try {
92707       try {
92708         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);
92709       }
92710       catch(std::out_of_range &_e) {
92711         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92712         return 0;
92713       }
92714       catch(std::invalid_argument &_e) {
92715         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92716         return 0;
92717       }
92718
92719     } catch (std::out_of_range& e) {
92720       {
92721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92722       };
92723     } catch (std::exception& e) {
92724       {
92725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92726       };
92727     } catch (Dali::DaliException e) {
92728       {
92729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92730       };
92731     } catch (...) {
92732       {
92733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92734       };
92735     }
92736   }
92737
92738   jresult = (void *)result;
92739   return jresult;
92740 }
92741
92742
92743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92744   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92745   int arg2 ;
92746   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92747
92748   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92749   arg2 = (int)jarg2;
92750   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92751   if (!arg3) {
92752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92753     return ;
92754   }
92755   {
92756     try {
92757       try {
92758         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);
92759       }
92760       catch(std::out_of_range &_e) {
92761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92762         return ;
92763       }
92764
92765     } catch (std::out_of_range& e) {
92766       {
92767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92768       };
92769     } catch (std::exception& e) {
92770       {
92771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92772       };
92773     } catch (Dali::DaliException e) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92776       };
92777     } catch (...) {
92778       {
92779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92780       };
92781     }
92782   }
92783
92784 }
92785
92786
92787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92788   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92789   int arg2 ;
92790   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
92791
92792   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92793   arg2 = (int)jarg2;
92794   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
92795   if (!arg3) {
92796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92797     return ;
92798   }
92799   {
92800     try {
92801       try {
92802         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);
92803       }
92804       catch(std::out_of_range &_e) {
92805         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92806         return ;
92807       }
92808
92809     } catch (std::out_of_range& e) {
92810       {
92811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92812       };
92813     } catch (std::exception& e) {
92814       {
92815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92816       };
92817     } catch (Dali::DaliException e) {
92818       {
92819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92820       };
92821     } catch (...) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92824       };
92825     }
92826   }
92827
92828 }
92829
92830
92831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
92832   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92833   int arg2 ;
92834
92835   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92836   arg2 = (int)jarg2;
92837   {
92838     try {
92839       try {
92840         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
92841       }
92842       catch(std::out_of_range &_e) {
92843         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92844         return ;
92845       }
92846
92847     } catch (std::out_of_range& e) {
92848       {
92849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92850       };
92851     } catch (std::exception& e) {
92852       {
92853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92854       };
92855     } catch (Dali::DaliException e) {
92856       {
92857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92858       };
92859     } catch (...) {
92860       {
92861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92862       };
92863     }
92864   }
92865
92866 }
92867
92868
92869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92870   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92871   int arg2 ;
92872   int arg3 ;
92873
92874   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92875   arg2 = (int)jarg2;
92876   arg3 = (int)jarg3;
92877   {
92878     try {
92879       try {
92880         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
92881       }
92882       catch(std::out_of_range &_e) {
92883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92884         return ;
92885       }
92886       catch(std::invalid_argument &_e) {
92887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92888         return ;
92889       }
92890
92891     } catch (std::out_of_range& e) {
92892       {
92893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92894       };
92895     } catch (std::exception& e) {
92896       {
92897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92898       };
92899     } catch (Dali::DaliException e) {
92900       {
92901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92902       };
92903     } catch (...) {
92904       {
92905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92906       };
92907     }
92908   }
92909
92910 }
92911
92912
92913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
92914   void * jresult ;
92915   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92916   int arg2 ;
92917   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92918
92919   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92920   if (!arg1) {
92921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92922     return 0;
92923   }
92924   arg2 = (int)jarg2;
92925   {
92926     try {
92927       try {
92928         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);
92929       }
92930       catch(std::out_of_range &_e) {
92931         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92932         return 0;
92933       }
92934
92935     } catch (std::out_of_range& e) {
92936       {
92937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92938       };
92939     } catch (std::exception& e) {
92940       {
92941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92942       };
92943     } catch (Dali::DaliException e) {
92944       {
92945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92946       };
92947     } catch (...) {
92948       {
92949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92950       };
92951     }
92952   }
92953
92954   jresult = (void *)result;
92955   return jresult;
92956 }
92957
92958
92959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
92960   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92961
92962   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92963   {
92964     try {
92965       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92973       };
92974     } catch (Dali::DaliException e) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92977       };
92978     } catch (...) {
92979       {
92980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92981       };
92982     }
92983   }
92984
92985 }
92986
92987
92988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92989   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92990   int arg2 ;
92991   int arg3 ;
92992
92993   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92994   arg2 = (int)jarg2;
92995   arg3 = (int)jarg3;
92996   {
92997     try {
92998       try {
92999         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93000       }
93001       catch(std::out_of_range &_e) {
93002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93003         return ;
93004       }
93005       catch(std::invalid_argument &_e) {
93006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93007         return ;
93008       }
93009
93010     } catch (std::out_of_range& e) {
93011       {
93012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93013       };
93014     } catch (std::exception& e) {
93015       {
93016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93017       };
93018     } catch (Dali::DaliException e) {
93019       {
93020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93021       };
93022     } catch (...) {
93023       {
93024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93025       };
93026     }
93027   }
93028
93029 }
93030
93031
93032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93033   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93034   int arg2 ;
93035   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93036
93037   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93038   arg2 = (int)jarg2;
93039   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93040   if (!arg3) {
93041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93042     return ;
93043   }
93044   {
93045     try {
93046       try {
93047         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);
93048       }
93049       catch(std::out_of_range &_e) {
93050         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93051         return ;
93052       }
93053
93054     } catch (std::out_of_range& e) {
93055       {
93056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93057       };
93058     } catch (std::exception& e) {
93059       {
93060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93061       };
93062     } catch (Dali::DaliException e) {
93063       {
93064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93065       };
93066     } catch (...) {
93067       {
93068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93069       };
93070     }
93071   }
93072
93073 }
93074
93075
93076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93077   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93078
93079   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93080   {
93081     try {
93082       delete arg1;
93083     } catch (std::out_of_range& e) {
93084       {
93085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93086       };
93087     } catch (std::exception& e) {
93088       {
93089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93090       };
93091     } catch (Dali::DaliException e) {
93092       {
93093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93094       };
93095     } catch (...) {
93096       {
93097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93098       };
93099     }
93100   }
93101
93102 }
93103
93104
93105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93106   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93107
93108   arg1 = (std::vector< Dali::Actor > *)jarg1;
93109   {
93110     try {
93111       (arg1)->clear();
93112     } catch (std::out_of_range& e) {
93113       {
93114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (std::exception& e) {
93117       {
93118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93119       };
93120     } catch (Dali::DaliException e) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93123       };
93124     } catch (...) {
93125       {
93126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93127       };
93128     }
93129   }
93130
93131 }
93132
93133
93134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93135   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93136   Dali::Actor *arg2 = 0 ;
93137
93138   arg1 = (std::vector< Dali::Actor > *)jarg1;
93139   arg2 = (Dali::Actor *)jarg2;
93140   if (!arg2) {
93141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93142     return ;
93143   }
93144   {
93145     try {
93146       (arg1)->push_back((Dali::Actor const &)*arg2);
93147     } catch (std::out_of_range& e) {
93148       {
93149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93150       };
93151     } catch (std::exception& e) {
93152       {
93153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93154       };
93155     } catch (Dali::DaliException e) {
93156       {
93157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93158       };
93159     } catch (...) {
93160       {
93161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93162       };
93163     }
93164   }
93165
93166 }
93167
93168
93169 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93170   unsigned long jresult ;
93171   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93172   std::vector< Dali::Actor >::size_type result;
93173
93174   arg1 = (std::vector< Dali::Actor > *)jarg1;
93175   {
93176     try {
93177       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93178     } catch (std::out_of_range& e) {
93179       {
93180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (std::exception& e) {
93183       {
93184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93185       };
93186     } catch (Dali::DaliException e) {
93187       {
93188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93189       };
93190     } catch (...) {
93191       {
93192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93193       };
93194     }
93195   }
93196
93197   jresult = (unsigned long)result;
93198   return jresult;
93199 }
93200
93201
93202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93203   unsigned long jresult ;
93204   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93205   std::vector< Dali::Actor >::size_type result;
93206
93207   arg1 = (std::vector< Dali::Actor > *)jarg1;
93208   {
93209     try {
93210       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93211     } catch (std::out_of_range& e) {
93212       {
93213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93214       };
93215     } catch (std::exception& e) {
93216       {
93217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93218       };
93219     } catch (Dali::DaliException e) {
93220       {
93221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93222       };
93223     } catch (...) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93226       };
93227     }
93228   }
93229
93230   jresult = (unsigned long)result;
93231   return jresult;
93232 }
93233
93234
93235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93236   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93237   std::vector< Dali::Actor >::size_type arg2 ;
93238
93239   arg1 = (std::vector< Dali::Actor > *)jarg1;
93240   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93241   {
93242     try {
93243       (arg1)->reserve(arg2);
93244     } catch (std::out_of_range& e) {
93245       {
93246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93247       };
93248     } catch (std::exception& e) {
93249       {
93250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93251       };
93252     } catch (Dali::DaliException e) {
93253       {
93254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93255       };
93256     } catch (...) {
93257       {
93258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93259       };
93260     }
93261   }
93262
93263 }
93264
93265
93266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93267   void * jresult ;
93268   std::vector< Dali::Actor > *result = 0 ;
93269
93270   {
93271     try {
93272       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93273     } catch (std::out_of_range& e) {
93274       {
93275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93276       };
93277     } catch (std::exception& e) {
93278       {
93279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93280       };
93281     } catch (Dali::DaliException e) {
93282       {
93283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93284       };
93285     } catch (...) {
93286       {
93287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93288       };
93289     }
93290   }
93291
93292   jresult = (void *)result;
93293   return jresult;
93294 }
93295
93296
93297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93298   void * jresult ;
93299   std::vector< Dali::Actor > *arg1 = 0 ;
93300   std::vector< Dali::Actor > *result = 0 ;
93301
93302   arg1 = (std::vector< Dali::Actor > *)jarg1;
93303   if (!arg1) {
93304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93305     return 0;
93306   }
93307   {
93308     try {
93309       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93310     } catch (std::out_of_range& e) {
93311       {
93312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93313       };
93314     } catch (std::exception& e) {
93315       {
93316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93317       };
93318     } catch (Dali::DaliException e) {
93319       {
93320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93321       };
93322     } catch (...) {
93323       {
93324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93325       };
93326     }
93327   }
93328
93329   jresult = (void *)result;
93330   return jresult;
93331 }
93332
93333
93334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93335   void * jresult ;
93336   int arg1 ;
93337   std::vector< Dali::Actor > *result = 0 ;
93338
93339   arg1 = (int)jarg1;
93340   {
93341     try {
93342       try {
93343         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93344       }
93345       catch(std::out_of_range &_e) {
93346         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93347         return 0;
93348       }
93349
93350     } catch (std::out_of_range& e) {
93351       {
93352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93353       };
93354     } catch (std::exception& e) {
93355       {
93356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93357       };
93358     } catch (Dali::DaliException e) {
93359       {
93360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93361       };
93362     } catch (...) {
93363       {
93364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93365       };
93366     }
93367   }
93368
93369   jresult = (void *)result;
93370   return jresult;
93371 }
93372
93373
93374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93375   void * jresult ;
93376   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93377   int arg2 ;
93378   Dali::Actor result;
93379
93380   arg1 = (std::vector< Dali::Actor > *)jarg1;
93381   arg2 = (int)jarg2;
93382   {
93383     try {
93384       try {
93385         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93386       }
93387       catch(std::out_of_range &_e) {
93388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93389         return 0;
93390       }
93391
93392     } catch (std::out_of_range& e) {
93393       {
93394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93395       };
93396     } catch (std::exception& e) {
93397       {
93398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93399       };
93400     } catch (Dali::DaliException e) {
93401       {
93402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93403       };
93404     } catch (...) {
93405       {
93406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93407       };
93408     }
93409   }
93410
93411   jresult = new Dali::Actor((const Dali::Actor &)result);
93412   return jresult;
93413 }
93414
93415
93416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93417   void * jresult ;
93418   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93419   int arg2 ;
93420   Dali::Actor *result = 0 ;
93421
93422   arg1 = (std::vector< Dali::Actor > *)jarg1;
93423   arg2 = (int)jarg2;
93424   {
93425     try {
93426       try {
93427         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93428       }
93429       catch(std::out_of_range &_e) {
93430         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93431         return 0;
93432       }
93433
93434     } catch (std::out_of_range& e) {
93435       {
93436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93437       };
93438     } catch (std::exception& e) {
93439       {
93440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93441       };
93442     } catch (Dali::DaliException e) {
93443       {
93444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93445       };
93446     } catch (...) {
93447       {
93448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93449       };
93450     }
93451   }
93452
93453   jresult = (void *)result;
93454   return jresult;
93455 }
93456
93457
93458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93459   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93460   int arg2 ;
93461   Dali::Actor *arg3 = 0 ;
93462
93463   arg1 = (std::vector< Dali::Actor > *)jarg1;
93464   arg2 = (int)jarg2;
93465   arg3 = (Dali::Actor *)jarg3;
93466   if (!arg3) {
93467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93468     return ;
93469   }
93470   {
93471     try {
93472       try {
93473         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93474       }
93475       catch(std::out_of_range &_e) {
93476         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93477         return ;
93478       }
93479
93480     } catch (std::out_of_range& e) {
93481       {
93482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93483       };
93484     } catch (std::exception& e) {
93485       {
93486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93487       };
93488     } catch (Dali::DaliException e) {
93489       {
93490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93491       };
93492     } catch (...) {
93493       {
93494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93495       };
93496     }
93497   }
93498
93499 }
93500
93501
93502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93503   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93504   std::vector< Dali::Actor > *arg2 = 0 ;
93505
93506   arg1 = (std::vector< Dali::Actor > *)jarg1;
93507   arg2 = (std::vector< Dali::Actor > *)jarg2;
93508   if (!arg2) {
93509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93510     return ;
93511   }
93512   {
93513     try {
93514       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93515     } catch (std::out_of_range& e) {
93516       {
93517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93518       };
93519     } catch (std::exception& e) {
93520       {
93521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93522       };
93523     } catch (Dali::DaliException e) {
93524       {
93525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93526       };
93527     } catch (...) {
93528       {
93529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93530       };
93531     }
93532   }
93533
93534 }
93535
93536
93537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93538   void * jresult ;
93539   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93540   int arg2 ;
93541   int arg3 ;
93542   std::vector< Dali::Actor > *result = 0 ;
93543
93544   arg1 = (std::vector< Dali::Actor > *)jarg1;
93545   arg2 = (int)jarg2;
93546   arg3 = (int)jarg3;
93547   {
93548     try {
93549       try {
93550         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93551       }
93552       catch(std::out_of_range &_e) {
93553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93554         return 0;
93555       }
93556       catch(std::invalid_argument &_e) {
93557         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93558         return 0;
93559       }
93560
93561     } catch (std::out_of_range& e) {
93562       {
93563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93564       };
93565     } catch (std::exception& e) {
93566       {
93567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93568       };
93569     } catch (Dali::DaliException e) {
93570       {
93571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93572       };
93573     } catch (...) {
93574       {
93575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93576       };
93577     }
93578   }
93579
93580   jresult = (void *)result;
93581   return jresult;
93582 }
93583
93584
93585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93586   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93587   int arg2 ;
93588   Dali::Actor *arg3 = 0 ;
93589
93590   arg1 = (std::vector< Dali::Actor > *)jarg1;
93591   arg2 = (int)jarg2;
93592   arg3 = (Dali::Actor *)jarg3;
93593   if (!arg3) {
93594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93595     return ;
93596   }
93597   {
93598     try {
93599       try {
93600         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93601       }
93602       catch(std::out_of_range &_e) {
93603         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93604         return ;
93605       }
93606
93607     } catch (std::out_of_range& e) {
93608       {
93609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93610       };
93611     } catch (std::exception& e) {
93612       {
93613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93614       };
93615     } catch (Dali::DaliException e) {
93616       {
93617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93618       };
93619     } catch (...) {
93620       {
93621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93622       };
93623     }
93624   }
93625
93626 }
93627
93628
93629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93630   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93631   int arg2 ;
93632   std::vector< Dali::Actor > *arg3 = 0 ;
93633
93634   arg1 = (std::vector< Dali::Actor > *)jarg1;
93635   arg2 = (int)jarg2;
93636   arg3 = (std::vector< Dali::Actor > *)jarg3;
93637   if (!arg3) {
93638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93639     return ;
93640   }
93641   {
93642     try {
93643       try {
93644         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93645       }
93646       catch(std::out_of_range &_e) {
93647         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93648         return ;
93649       }
93650
93651     } catch (std::out_of_range& e) {
93652       {
93653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93654       };
93655     } catch (std::exception& e) {
93656       {
93657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93658       };
93659     } catch (Dali::DaliException e) {
93660       {
93661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93662       };
93663     } catch (...) {
93664       {
93665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93666       };
93667     }
93668   }
93669
93670 }
93671
93672
93673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93674   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93675   int arg2 ;
93676
93677   arg1 = (std::vector< Dali::Actor > *)jarg1;
93678   arg2 = (int)jarg2;
93679   {
93680     try {
93681       try {
93682         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93683       }
93684       catch(std::out_of_range &_e) {
93685         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93686         return ;
93687       }
93688
93689     } catch (std::out_of_range& e) {
93690       {
93691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93692       };
93693     } catch (std::exception& e) {
93694       {
93695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93696       };
93697     } catch (Dali::DaliException e) {
93698       {
93699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93700       };
93701     } catch (...) {
93702       {
93703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93704       };
93705     }
93706   }
93707
93708 }
93709
93710
93711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93712   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93713   int arg2 ;
93714   int arg3 ;
93715
93716   arg1 = (std::vector< Dali::Actor > *)jarg1;
93717   arg2 = (int)jarg2;
93718   arg3 = (int)jarg3;
93719   {
93720     try {
93721       try {
93722         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93723       }
93724       catch(std::out_of_range &_e) {
93725         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93726         return ;
93727       }
93728       catch(std::invalid_argument &_e) {
93729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93730         return ;
93731       }
93732
93733     } catch (std::out_of_range& e) {
93734       {
93735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93736       };
93737     } catch (std::exception& e) {
93738       {
93739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93740       };
93741     } catch (Dali::DaliException e) {
93742       {
93743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93744       };
93745     } catch (...) {
93746       {
93747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93748       };
93749     }
93750   }
93751
93752 }
93753
93754
93755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
93756   void * jresult ;
93757   Dali::Actor *arg1 = 0 ;
93758   int arg2 ;
93759   std::vector< Dali::Actor > *result = 0 ;
93760
93761   arg1 = (Dali::Actor *)jarg1;
93762   if (!arg1) {
93763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93764     return 0;
93765   }
93766   arg2 = (int)jarg2;
93767   {
93768     try {
93769       try {
93770         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
93771       }
93772       catch(std::out_of_range &_e) {
93773         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93774         return 0;
93775       }
93776
93777     } catch (std::out_of_range& e) {
93778       {
93779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93780       };
93781     } catch (std::exception& e) {
93782       {
93783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93784       };
93785     } catch (Dali::DaliException e) {
93786       {
93787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93788       };
93789     } catch (...) {
93790       {
93791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93792       };
93793     }
93794   }
93795
93796   jresult = (void *)result;
93797   return jresult;
93798 }
93799
93800
93801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
93802   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93803
93804   arg1 = (std::vector< Dali::Actor > *)jarg1;
93805   {
93806     try {
93807       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
93808     } catch (std::out_of_range& e) {
93809       {
93810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93811       };
93812     } catch (std::exception& e) {
93813       {
93814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93815       };
93816     } catch (Dali::DaliException e) {
93817       {
93818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93819       };
93820     } catch (...) {
93821       {
93822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93823       };
93824     }
93825   }
93826
93827 }
93828
93829
93830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93831   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93832   int arg2 ;
93833   int arg3 ;
93834
93835   arg1 = (std::vector< Dali::Actor > *)jarg1;
93836   arg2 = (int)jarg2;
93837   arg3 = (int)jarg3;
93838   {
93839     try {
93840       try {
93841         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93842       }
93843       catch(std::out_of_range &_e) {
93844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93845         return ;
93846       }
93847       catch(std::invalid_argument &_e) {
93848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93849         return ;
93850       }
93851
93852     } catch (std::out_of_range& e) {
93853       {
93854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93855       };
93856     } catch (std::exception& e) {
93857       {
93858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93859       };
93860     } catch (Dali::DaliException e) {
93861       {
93862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93863       };
93864     } catch (...) {
93865       {
93866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93867       };
93868     }
93869   }
93870
93871 }
93872
93873
93874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93875   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93876   int arg2 ;
93877   std::vector< Dali::Actor > *arg3 = 0 ;
93878
93879   arg1 = (std::vector< Dali::Actor > *)jarg1;
93880   arg2 = (int)jarg2;
93881   arg3 = (std::vector< Dali::Actor > *)jarg3;
93882   if (!arg3) {
93883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93884     return ;
93885   }
93886   {
93887     try {
93888       try {
93889         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93890       }
93891       catch(std::out_of_range &_e) {
93892         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93893         return ;
93894       }
93895
93896     } catch (std::out_of_range& e) {
93897       {
93898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (std::exception& e) {
93901       {
93902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93903       };
93904     } catch (Dali::DaliException e) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93907       };
93908     } catch (...) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93911       };
93912     }
93913   }
93914
93915 }
93916
93917
93918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
93919   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93920
93921   arg1 = (std::vector< Dali::Actor > *)jarg1;
93922   {
93923     try {
93924       delete arg1;
93925     } catch (std::out_of_range& e) {
93926       {
93927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93928       };
93929     } catch (std::exception& e) {
93930       {
93931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93932       };
93933     } catch (Dali::DaliException e) {
93934       {
93935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93936       };
93937     } catch (...) {
93938       {
93939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93940       };
93941     }
93942   }
93943
93944 }
93945
93946
93947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
93948   unsigned int jresult ;
93949   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
93950   bool result;
93951
93952   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
93953   {
93954     try {
93955       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
93956     } catch (std::out_of_range& e) {
93957       {
93958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93959       };
93960     } catch (std::exception& e) {
93961       {
93962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (Dali::DaliException e) {
93965       {
93966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93967       };
93968     } catch (...) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93971       };
93972     }
93973   }
93974
93975   jresult = result;
93976   return jresult;
93977 }
93978
93979
93980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
93981   unsigned long jresult ;
93982   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
93983   std::size_t result;
93984
93985   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
93986   {
93987     try {
93988       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
93989     } catch (std::out_of_range& e) {
93990       {
93991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93992       };
93993     } catch (std::exception& e) {
93994       {
93995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93996       };
93997     } catch (Dali::DaliException e) {
93998       {
93999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94000       };
94001     } catch (...) {
94002       {
94003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94004       };
94005     }
94006   }
94007
94008   jresult = (unsigned long)result;
94009   return jresult;
94010 }
94011
94012
94013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94014   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94015   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94016
94017   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94018   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94019   {
94020     try {
94021       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94022     } catch (std::out_of_range& e) {
94023       {
94024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94025       };
94026     } catch (std::exception& e) {
94027       {
94028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94029       };
94030     } catch (Dali::DaliException e) {
94031       {
94032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94033       };
94034     } catch (...) {
94035       {
94036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94037       };
94038     }
94039   }
94040
94041 }
94042
94043
94044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94045   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94046   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94047
94048   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94049   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94050   {
94051     try {
94052       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94053     } catch (std::out_of_range& e) {
94054       {
94055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94056       };
94057     } catch (std::exception& e) {
94058       {
94059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94060       };
94061     } catch (Dali::DaliException e) {
94062       {
94063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94064       };
94065     } catch (...) {
94066       {
94067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94068       };
94069     }
94070   }
94071
94072 }
94073
94074
94075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94076   unsigned int jresult ;
94077   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94078   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94079   bool result;
94080
94081   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94082   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94083   if (!arg2) {
94084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94085     return 0;
94086   }
94087   {
94088     try {
94089       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94090     } catch (std::out_of_range& e) {
94091       {
94092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94093       };
94094     } catch (std::exception& e) {
94095       {
94096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94097       };
94098     } catch (Dali::DaliException e) {
94099       {
94100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94101       };
94102     } catch (...) {
94103       {
94104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94105       };
94106     }
94107   }
94108
94109   jresult = result;
94110   return jresult;
94111 }
94112
94113
94114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94115   void * jresult ;
94116   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94117
94118   {
94119     try {
94120       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94121     } catch (std::out_of_range& e) {
94122       {
94123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94124       };
94125     } catch (std::exception& e) {
94126       {
94127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94128       };
94129     } catch (Dali::DaliException e) {
94130       {
94131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94132       };
94133     } catch (...) {
94134       {
94135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94136       };
94137     }
94138   }
94139
94140   jresult = (void *)result;
94141   return jresult;
94142 }
94143
94144
94145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94146   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94147
94148   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94149   {
94150     try {
94151       delete arg1;
94152     } catch (std::out_of_range& e) {
94153       {
94154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94155       };
94156     } catch (std::exception& e) {
94157       {
94158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94159       };
94160     } catch (Dali::DaliException e) {
94161       {
94162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94163       };
94164     } catch (...) {
94165       {
94166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94167       };
94168     }
94169   }
94170
94171 }
94172
94173
94174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94175   unsigned int jresult ;
94176   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94177   bool result;
94178
94179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94180   {
94181     try {
94182       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);
94183     } catch (std::out_of_range& e) {
94184       {
94185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94186       };
94187     } catch (std::exception& e) {
94188       {
94189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94190       };
94191     } catch (Dali::DaliException e) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94194       };
94195     } catch (...) {
94196       {
94197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94198       };
94199     }
94200   }
94201
94202   jresult = result;
94203   return jresult;
94204 }
94205
94206
94207 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94208   unsigned long jresult ;
94209   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94210   std::size_t result;
94211
94212   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94213   {
94214     try {
94215       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);
94216     } catch (std::out_of_range& e) {
94217       {
94218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94219       };
94220     } catch (std::exception& e) {
94221       {
94222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94223       };
94224     } catch (Dali::DaliException e) {
94225       {
94226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94227       };
94228     } catch (...) {
94229       {
94230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94231       };
94232     }
94233   }
94234
94235   jresult = (unsigned long)result;
94236   return jresult;
94237 }
94238
94239
94240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94241   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94242   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94243
94244   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94245   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94246   {
94247     try {
94248       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94249     } catch (std::out_of_range& e) {
94250       {
94251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94252       };
94253     } catch (std::exception& e) {
94254       {
94255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94256       };
94257     } catch (Dali::DaliException e) {
94258       {
94259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94260       };
94261     } catch (...) {
94262       {
94263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94264       };
94265     }
94266   }
94267
94268 }
94269
94270
94271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94272   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94273   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94274
94275   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94276   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94277   {
94278     try {
94279       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94280     } catch (std::out_of_range& e) {
94281       {
94282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94283       };
94284     } catch (std::exception& e) {
94285       {
94286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94287       };
94288     } catch (Dali::DaliException e) {
94289       {
94290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94291       };
94292     } catch (...) {
94293       {
94294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94295       };
94296     }
94297   }
94298
94299 }
94300
94301
94302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94303   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94304   Dali::Actor arg2 ;
94305   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94306   Dali::Actor *argp2 ;
94307
94308   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94309   argp2 = (Dali::Actor *)jarg2;
94310   if (!argp2) {
94311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94312     return ;
94313   }
94314   arg2 = *argp2;
94315   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94316   {
94317     try {
94318       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94319     } catch (std::out_of_range& e) {
94320       {
94321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94322       };
94323     } catch (std::exception& e) {
94324       {
94325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94326       };
94327     } catch (Dali::DaliException e) {
94328       {
94329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94330       };
94331     } catch (...) {
94332       {
94333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94334       };
94335     }
94336   }
94337
94338 }
94339
94340
94341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94342   void * jresult ;
94343   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94344
94345   {
94346     try {
94347       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94348     } catch (std::out_of_range& e) {
94349       {
94350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94351       };
94352     } catch (std::exception& e) {
94353       {
94354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94355       };
94356     } catch (Dali::DaliException e) {
94357       {
94358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94359       };
94360     } catch (...) {
94361       {
94362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94363       };
94364     }
94365   }
94366
94367   jresult = (void *)result;
94368   return jresult;
94369 }
94370
94371
94372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94373   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94374
94375   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94376   {
94377     try {
94378       delete arg1;
94379     } catch (std::out_of_range& e) {
94380       {
94381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94382       };
94383     } catch (std::exception& e) {
94384       {
94385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94386       };
94387     } catch (Dali::DaliException e) {
94388       {
94389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94390       };
94391     } catch (...) {
94392       {
94393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94394       };
94395     }
94396   }
94397
94398 }
94399
94400
94401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94402   unsigned int jresult ;
94403   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94404   bool result;
94405
94406   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94407   {
94408     try {
94409       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94410     } catch (std::out_of_range& e) {
94411       {
94412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94413       };
94414     } catch (std::exception& e) {
94415       {
94416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94417       };
94418     } catch (Dali::DaliException e) {
94419       {
94420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94421       };
94422     } catch (...) {
94423       {
94424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94425       };
94426     }
94427   }
94428
94429   jresult = result;
94430   return jresult;
94431 }
94432
94433
94434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94435   unsigned long jresult ;
94436   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94437   std::size_t result;
94438
94439   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94440   {
94441     try {
94442       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94443     } catch (std::out_of_range& e) {
94444       {
94445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94446       };
94447     } catch (std::exception& e) {
94448       {
94449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (Dali::DaliException e) {
94452       {
94453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94454       };
94455     } catch (...) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94458       };
94459     }
94460   }
94461
94462   jresult = (unsigned long)result;
94463   return jresult;
94464 }
94465
94466
94467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94468   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94469   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94470
94471   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94472   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94473   {
94474     try {
94475       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94476     } catch (std::out_of_range& e) {
94477       {
94478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94479       };
94480     } catch (std::exception& e) {
94481       {
94482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94483       };
94484     } catch (Dali::DaliException e) {
94485       {
94486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94487       };
94488     } catch (...) {
94489       {
94490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94491       };
94492     }
94493   }
94494
94495 }
94496
94497
94498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94499   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94500   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94501
94502   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94503   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94504   {
94505     try {
94506       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94507     } catch (std::out_of_range& e) {
94508       {
94509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94510       };
94511     } catch (std::exception& e) {
94512       {
94513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94514       };
94515     } catch (Dali::DaliException e) {
94516       {
94517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94518       };
94519     } catch (...) {
94520       {
94521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94522       };
94523     }
94524   }
94525
94526 }
94527
94528
94529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94530   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94531   Dali::Actor arg2 ;
94532   Dali::Actor arg3 ;
94533   Dali::Actor *argp2 ;
94534   Dali::Actor *argp3 ;
94535
94536   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94537   argp2 = (Dali::Actor *)jarg2;
94538   if (!argp2) {
94539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94540     return ;
94541   }
94542   arg2 = *argp2;
94543   argp3 = (Dali::Actor *)jarg3;
94544   if (!argp3) {
94545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94546     return ;
94547   }
94548   arg3 = *argp3;
94549   {
94550     try {
94551       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94552     } catch (std::out_of_range& e) {
94553       {
94554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94555       };
94556     } catch (std::exception& e) {
94557       {
94558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94559       };
94560     } catch (Dali::DaliException e) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94563       };
94564     } catch (...) {
94565       {
94566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94567       };
94568     }
94569   }
94570
94571 }
94572
94573
94574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94575   void * jresult ;
94576   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94577
94578   {
94579     try {
94580       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94581     } catch (std::out_of_range& e) {
94582       {
94583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94584       };
94585     } catch (std::exception& e) {
94586       {
94587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94588       };
94589     } catch (Dali::DaliException e) {
94590       {
94591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94592       };
94593     } catch (...) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94596       };
94597     }
94598   }
94599
94600   jresult = (void *)result;
94601   return jresult;
94602 }
94603
94604
94605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94606   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94607
94608   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94609   {
94610     try {
94611       delete arg1;
94612     } catch (std::out_of_range& e) {
94613       {
94614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94615       };
94616     } catch (std::exception& e) {
94617       {
94618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94619       };
94620     } catch (Dali::DaliException e) {
94621       {
94622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94623       };
94624     } catch (...) {
94625       {
94626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94627       };
94628     }
94629   }
94630
94631 }
94632
94633
94634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94635   unsigned int jresult ;
94636   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94637   bool result;
94638
94639   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94640   {
94641     try {
94642       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94643     } catch (std::out_of_range& e) {
94644       {
94645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94646       };
94647     } catch (std::exception& e) {
94648       {
94649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94650       };
94651     } catch (Dali::DaliException e) {
94652       {
94653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94654       };
94655     } catch (...) {
94656       {
94657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94658       };
94659     }
94660   }
94661
94662   jresult = result;
94663   return jresult;
94664 }
94665
94666
94667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94668   unsigned long jresult ;
94669   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94670   std::size_t result;
94671
94672   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94673   {
94674     try {
94675       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94676     } catch (std::out_of_range& e) {
94677       {
94678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94679       };
94680     } catch (std::exception& e) {
94681       {
94682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94683       };
94684     } catch (Dali::DaliException e) {
94685       {
94686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94687       };
94688     } catch (...) {
94689       {
94690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94691       };
94692     }
94693   }
94694
94695   jresult = (unsigned long)result;
94696   return jresult;
94697 }
94698
94699
94700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94701   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94702   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94703
94704   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94705   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94706   {
94707     try {
94708       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94709     } catch (std::out_of_range& e) {
94710       {
94711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94712       };
94713     } catch (std::exception& e) {
94714       {
94715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94716       };
94717     } catch (Dali::DaliException e) {
94718       {
94719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94720       };
94721     } catch (...) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94724       };
94725     }
94726   }
94727
94728 }
94729
94730
94731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94732   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94733   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94734
94735   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94736   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94737   {
94738     try {
94739       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94740     } catch (std::out_of_range& e) {
94741       {
94742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94743       };
94744     } catch (std::exception& e) {
94745       {
94746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94747       };
94748     } catch (Dali::DaliException e) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94751       };
94752     } catch (...) {
94753       {
94754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94755       };
94756     }
94757   }
94758
94759 }
94760
94761
94762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
94763   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94764   Dali::Actor arg2 ;
94765   bool arg3 ;
94766   Dali::Actor *argp2 ;
94767
94768   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94769   argp2 = (Dali::Actor *)jarg2;
94770   if (!argp2) {
94771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94772     return ;
94773   }
94774   arg2 = *argp2;
94775   arg3 = jarg3 ? true : false;
94776   {
94777     try {
94778       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
94779     } catch (std::out_of_range& e) {
94780       {
94781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94782       };
94783     } catch (std::exception& e) {
94784       {
94785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94786       };
94787     } catch (Dali::DaliException e) {
94788       {
94789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94790       };
94791     } catch (...) {
94792       {
94793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94794       };
94795     }
94796   }
94797
94798 }
94799
94800
94801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
94802   void * jresult ;
94803   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
94804
94805   {
94806     try {
94807       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
94808     } catch (std::out_of_range& e) {
94809       {
94810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94811       };
94812     } catch (std::exception& e) {
94813       {
94814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94815       };
94816     } catch (Dali::DaliException e) {
94817       {
94818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94819       };
94820     } catch (...) {
94821       {
94822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94823       };
94824     }
94825   }
94826
94827   jresult = (void *)result;
94828   return jresult;
94829 }
94830
94831
94832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
94833   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94834
94835   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94836   {
94837     try {
94838       delete arg1;
94839     } catch (std::out_of_range& e) {
94840       {
94841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94842       };
94843     } catch (std::exception& e) {
94844       {
94845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94846       };
94847     } catch (Dali::DaliException e) {
94848       {
94849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94850       };
94851     } catch (...) {
94852       {
94853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94854       };
94855     }
94856   }
94857
94858 }
94859
94860
94861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
94862   unsigned int jresult ;
94863   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94864   bool result;
94865
94866   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94867   {
94868     try {
94869       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);
94870     } catch (std::out_of_range& e) {
94871       {
94872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94873       };
94874     } catch (std::exception& e) {
94875       {
94876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94877       };
94878     } catch (Dali::DaliException e) {
94879       {
94880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94881       };
94882     } catch (...) {
94883       {
94884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94885       };
94886     }
94887   }
94888
94889   jresult = result;
94890   return jresult;
94891 }
94892
94893
94894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
94895   unsigned long jresult ;
94896   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94897   std::size_t result;
94898
94899   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94900   {
94901     try {
94902       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);
94903     } catch (std::out_of_range& e) {
94904       {
94905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94906       };
94907     } catch (std::exception& e) {
94908       {
94909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94910       };
94911     } catch (Dali::DaliException e) {
94912       {
94913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94914       };
94915     } catch (...) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94918       };
94919     }
94920   }
94921
94922   jresult = (unsigned long)result;
94923   return jresult;
94924 }
94925
94926
94927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
94928   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94929   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
94930
94931   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94932   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
94933   {
94934     try {
94935       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
94936     } catch (std::out_of_range& e) {
94937       {
94938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94939       };
94940     } catch (std::exception& e) {
94941       {
94942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94943       };
94944     } catch (Dali::DaliException e) {
94945       {
94946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94947       };
94948     } catch (...) {
94949       {
94950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94951       };
94952     }
94953   }
94954
94955 }
94956
94957
94958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94959   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94960   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
94961
94962   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94963   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
94964   {
94965     try {
94966       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
94967     } catch (std::out_of_range& e) {
94968       {
94969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94970       };
94971     } catch (std::exception& e) {
94972       {
94973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94974       };
94975     } catch (Dali::DaliException e) {
94976       {
94977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94978       };
94979     } catch (...) {
94980       {
94981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94982       };
94983     }
94984   }
94985
94986 }
94987
94988
94989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94990   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94991   Dali::Toolkit::StyleManager arg2 ;
94992   Dali::StyleChange::Type arg3 ;
94993   Dali::Toolkit::StyleManager *argp2 ;
94994
94995   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94996   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
94997   if (!argp2) {
94998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
94999     return ;
95000   }
95001   arg2 = *argp2;
95002   arg3 = (Dali::StyleChange::Type)jarg3;
95003   {
95004     try {
95005       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95006     } catch (std::out_of_range& e) {
95007       {
95008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95009       };
95010     } catch (std::exception& e) {
95011       {
95012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95013       };
95014     } catch (Dali::DaliException e) {
95015       {
95016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95017       };
95018     } catch (...) {
95019       {
95020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95021       };
95022     }
95023   }
95024
95025 }
95026
95027
95028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95029   void * jresult ;
95030   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95031
95032   {
95033     try {
95034       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95035     } catch (std::out_of_range& e) {
95036       {
95037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95038       };
95039     } catch (std::exception& e) {
95040       {
95041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95042       };
95043     } catch (Dali::DaliException e) {
95044       {
95045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95046       };
95047     } catch (...) {
95048       {
95049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95050       };
95051     }
95052   }
95053
95054   jresult = (void *)result;
95055   return jresult;
95056 }
95057
95058
95059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95060   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95061
95062   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95063   {
95064     try {
95065       delete arg1;
95066     } catch (std::out_of_range& e) {
95067       {
95068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95069       };
95070     } catch (std::exception& e) {
95071       {
95072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95073       };
95074     } catch (Dali::DaliException e) {
95075       {
95076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95077       };
95078     } catch (...) {
95079       {
95080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95081       };
95082     }
95083   }
95084
95085 }
95086
95087
95088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95089   unsigned int jresult ;
95090   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95091   bool result;
95092
95093   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95094   {
95095     try {
95096       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95097     } catch (std::out_of_range& e) {
95098       {
95099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95100       };
95101     } catch (std::exception& e) {
95102       {
95103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95104       };
95105     } catch (Dali::DaliException e) {
95106       {
95107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95108       };
95109     } catch (...) {
95110       {
95111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95112       };
95113     }
95114   }
95115
95116   jresult = result;
95117   return jresult;
95118 }
95119
95120
95121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95122   unsigned long jresult ;
95123   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95124   std::size_t result;
95125
95126   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95127   {
95128     try {
95129       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95130     } catch (std::out_of_range& e) {
95131       {
95132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95133       };
95134     } catch (std::exception& e) {
95135       {
95136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (Dali::DaliException e) {
95139       {
95140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95141       };
95142     } catch (...) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95145       };
95146     }
95147   }
95148
95149   jresult = (unsigned long)result;
95150   return jresult;
95151 }
95152
95153
95154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95155   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95156   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95157
95158   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95159   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95160   {
95161     try {
95162       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95163     } catch (std::out_of_range& e) {
95164       {
95165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95166       };
95167     } catch (std::exception& e) {
95168       {
95169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95170       };
95171     } catch (Dali::DaliException e) {
95172       {
95173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95174       };
95175     } catch (...) {
95176       {
95177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95178       };
95179     }
95180   }
95181
95182 }
95183
95184
95185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95186   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95187   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95188
95189   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95190   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95191   {
95192     try {
95193       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95194     } catch (std::out_of_range& e) {
95195       {
95196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95197       };
95198     } catch (std::exception& e) {
95199       {
95200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95201       };
95202     } catch (Dali::DaliException e) {
95203       {
95204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95205       };
95206     } catch (...) {
95207       {
95208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95209       };
95210     }
95211   }
95212
95213 }
95214
95215
95216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95217   unsigned int jresult ;
95218   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95219   Dali::Toolkit::Button arg2 ;
95220   Dali::Toolkit::Button *argp2 ;
95221   bool result;
95222
95223   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95224   argp2 = (Dali::Toolkit::Button *)jarg2;
95225   if (!argp2) {
95226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95227     return 0;
95228   }
95229   arg2 = *argp2;
95230   {
95231     try {
95232       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95233     } catch (std::out_of_range& e) {
95234       {
95235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95236       };
95237     } catch (std::exception& e) {
95238       {
95239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95240       };
95241     } catch (Dali::DaliException e) {
95242       {
95243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95244       };
95245     } catch (...) {
95246       {
95247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95248       };
95249     }
95250   }
95251
95252   jresult = result;
95253   return jresult;
95254 }
95255
95256
95257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95258   void * jresult ;
95259   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95260
95261   {
95262     try {
95263       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95264     } catch (std::out_of_range& e) {
95265       {
95266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95267       };
95268     } catch (std::exception& e) {
95269       {
95270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95271       };
95272     } catch (Dali::DaliException e) {
95273       {
95274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95275       };
95276     } catch (...) {
95277       {
95278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95279       };
95280     }
95281   }
95282
95283   jresult = (void *)result;
95284   return jresult;
95285 }
95286
95287
95288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95289   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95290
95291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95292   {
95293     try {
95294       delete arg1;
95295     } catch (std::out_of_range& e) {
95296       {
95297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95298       };
95299     } catch (std::exception& e) {
95300       {
95301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95302       };
95303     } catch (Dali::DaliException e) {
95304       {
95305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95306       };
95307     } catch (...) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95310       };
95311     }
95312   }
95313
95314 }
95315
95316
95317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95318   unsigned int jresult ;
95319   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95320   bool result;
95321
95322   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95323   {
95324     try {
95325       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95326     } catch (std::out_of_range& e) {
95327       {
95328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95329       };
95330     } catch (std::exception& e) {
95331       {
95332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95333       };
95334     } catch (Dali::DaliException e) {
95335       {
95336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95337       };
95338     } catch (...) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95341       };
95342     }
95343   }
95344
95345   jresult = result;
95346   return jresult;
95347 }
95348
95349
95350 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95351   unsigned long jresult ;
95352   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95353   std::size_t result;
95354
95355   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95356   {
95357     try {
95358       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95359     } catch (std::out_of_range& e) {
95360       {
95361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95362       };
95363     } catch (std::exception& e) {
95364       {
95365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95366       };
95367     } catch (Dali::DaliException e) {
95368       {
95369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95370       };
95371     } catch (...) {
95372       {
95373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95374       };
95375     }
95376   }
95377
95378   jresult = (unsigned long)result;
95379   return jresult;
95380 }
95381
95382
95383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95384   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95385   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95386
95387   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95388   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95389   {
95390     try {
95391       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95392     } catch (std::out_of_range& e) {
95393       {
95394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95395       };
95396     } catch (std::exception& e) {
95397       {
95398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95399       };
95400     } catch (Dali::DaliException e) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95403       };
95404     } catch (...) {
95405       {
95406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95407       };
95408     }
95409   }
95410
95411 }
95412
95413
95414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95415   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95416   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95417
95418   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95419   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95420   {
95421     try {
95422       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95423     } catch (std::out_of_range& e) {
95424       {
95425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95426       };
95427     } catch (std::exception& e) {
95428       {
95429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95430       };
95431     } catch (Dali::DaliException e) {
95432       {
95433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95434       };
95435     } catch (...) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95438       };
95439     }
95440   }
95441
95442 }
95443
95444
95445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95446   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95447   Dali::Toolkit::GaussianBlurView arg2 ;
95448   Dali::Toolkit::GaussianBlurView *argp2 ;
95449
95450   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95451   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95452   if (!argp2) {
95453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95454     return ;
95455   }
95456   arg2 = *argp2;
95457   {
95458     try {
95459       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95460     } catch (std::out_of_range& e) {
95461       {
95462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95463       };
95464     } catch (std::exception& e) {
95465       {
95466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95467       };
95468     } catch (Dali::DaliException e) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95471       };
95472     } catch (...) {
95473       {
95474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95475       };
95476     }
95477   }
95478
95479 }
95480
95481
95482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95483   void * jresult ;
95484   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95485
95486   {
95487     try {
95488       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95489     } catch (std::out_of_range& e) {
95490       {
95491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95492       };
95493     } catch (std::exception& e) {
95494       {
95495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95496       };
95497     } catch (Dali::DaliException e) {
95498       {
95499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95500       };
95501     } catch (...) {
95502       {
95503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95504       };
95505     }
95506   }
95507
95508   jresult = (void *)result;
95509   return jresult;
95510 }
95511
95512
95513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95514   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95515
95516   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95517   {
95518     try {
95519       delete arg1;
95520     } catch (std::out_of_range& e) {
95521       {
95522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95523       };
95524     } catch (std::exception& e) {
95525       {
95526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95527       };
95528     } catch (Dali::DaliException e) {
95529       {
95530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95531       };
95532     } catch (...) {
95533       {
95534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95535       };
95536     }
95537   }
95538
95539 }
95540
95541
95542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95543   unsigned int jresult ;
95544   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95545   bool result;
95546
95547   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95548   {
95549     try {
95550       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);
95551     } catch (std::out_of_range& e) {
95552       {
95553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95554       };
95555     } catch (std::exception& e) {
95556       {
95557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95558       };
95559     } catch (Dali::DaliException e) {
95560       {
95561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95562       };
95563     } catch (...) {
95564       {
95565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95566       };
95567     }
95568   }
95569
95570   jresult = result;
95571   return jresult;
95572 }
95573
95574
95575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95576   unsigned long jresult ;
95577   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95578   std::size_t result;
95579
95580   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95581   {
95582     try {
95583       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);
95584     } catch (std::out_of_range& e) {
95585       {
95586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95587       };
95588     } catch (std::exception& e) {
95589       {
95590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95591       };
95592     } catch (Dali::DaliException e) {
95593       {
95594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95595       };
95596     } catch (...) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95599       };
95600     }
95601   }
95602
95603   jresult = (unsigned long)result;
95604   return jresult;
95605 }
95606
95607
95608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95609   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95610   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95611
95612   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95613   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95614   {
95615     try {
95616       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95617     } catch (std::out_of_range& e) {
95618       {
95619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95620       };
95621     } catch (std::exception& e) {
95622       {
95623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95624       };
95625     } catch (Dali::DaliException e) {
95626       {
95627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95628       };
95629     } catch (...) {
95630       {
95631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95632       };
95633     }
95634   }
95635
95636 }
95637
95638
95639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95640   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95641   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95642
95643   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95644   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95645   {
95646     try {
95647       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95648     } catch (std::out_of_range& e) {
95649       {
95650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95651       };
95652     } catch (std::exception& e) {
95653       {
95654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95655       };
95656     } catch (Dali::DaliException e) {
95657       {
95658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95659       };
95660     } catch (...) {
95661       {
95662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95663       };
95664     }
95665   }
95666
95667 }
95668
95669
95670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95671   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95672   Dali::Toolkit::PageTurnView arg2 ;
95673   unsigned int arg3 ;
95674   bool arg4 ;
95675   Dali::Toolkit::PageTurnView *argp2 ;
95676
95677   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95678   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95679   if (!argp2) {
95680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95681     return ;
95682   }
95683   arg2 = *argp2;
95684   arg3 = (unsigned int)jarg3;
95685   arg4 = jarg4 ? true : false;
95686   {
95687     try {
95688       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95689     } catch (std::out_of_range& e) {
95690       {
95691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95692       };
95693     } catch (std::exception& e) {
95694       {
95695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95696       };
95697     } catch (Dali::DaliException e) {
95698       {
95699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95700       };
95701     } catch (...) {
95702       {
95703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95704       };
95705     }
95706   }
95707
95708 }
95709
95710
95711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95712   void * jresult ;
95713   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95714
95715   {
95716     try {
95717       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95718     } catch (std::out_of_range& e) {
95719       {
95720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95721       };
95722     } catch (std::exception& e) {
95723       {
95724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95725       };
95726     } catch (Dali::DaliException e) {
95727       {
95728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95729       };
95730     } catch (...) {
95731       {
95732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95733       };
95734     }
95735   }
95736
95737   jresult = (void *)result;
95738   return jresult;
95739 }
95740
95741
95742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
95743   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95744
95745   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95746   {
95747     try {
95748       delete arg1;
95749     } catch (std::out_of_range& e) {
95750       {
95751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95752       };
95753     } catch (std::exception& e) {
95754       {
95755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95756       };
95757     } catch (Dali::DaliException e) {
95758       {
95759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95760       };
95761     } catch (...) {
95762       {
95763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95764       };
95765     }
95766   }
95767
95768 }
95769
95770
95771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
95772   unsigned int jresult ;
95773   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95774   bool result;
95775
95776   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95777   {
95778     try {
95779       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95780     } catch (std::out_of_range& e) {
95781       {
95782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95783       };
95784     } catch (std::exception& e) {
95785       {
95786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95787       };
95788     } catch (Dali::DaliException e) {
95789       {
95790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95791       };
95792     } catch (...) {
95793       {
95794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95795       };
95796     }
95797   }
95798
95799   jresult = result;
95800   return jresult;
95801 }
95802
95803
95804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
95805   unsigned long jresult ;
95806   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95807   std::size_t result;
95808
95809   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95810   {
95811     try {
95812       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95813     } catch (std::out_of_range& e) {
95814       {
95815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95816       };
95817     } catch (std::exception& e) {
95818       {
95819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95820       };
95821     } catch (Dali::DaliException e) {
95822       {
95823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95824       };
95825     } catch (...) {
95826       {
95827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95828       };
95829     }
95830   }
95831
95832   jresult = (unsigned long)result;
95833   return jresult;
95834 }
95835
95836
95837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
95838   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95839   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95840
95841   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95842   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95843   {
95844     try {
95845       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
95846     } catch (std::out_of_range& e) {
95847       {
95848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95849       };
95850     } catch (std::exception& e) {
95851       {
95852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95853       };
95854     } catch (Dali::DaliException e) {
95855       {
95856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95857       };
95858     } catch (...) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95861       };
95862     }
95863   }
95864
95865 }
95866
95867
95868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
95869   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95870   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95871
95872   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95873   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95874   {
95875     try {
95876       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
95877     } catch (std::out_of_range& e) {
95878       {
95879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95880       };
95881     } catch (std::exception& e) {
95882       {
95883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95884       };
95885     } catch (Dali::DaliException e) {
95886       {
95887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95888       };
95889     } catch (...) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95892       };
95893     }
95894   }
95895
95896 }
95897
95898
95899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
95900   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95901   Dali::Toolkit::PageTurnView arg2 ;
95902   Dali::Toolkit::PageTurnView *argp2 ;
95903
95904   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95905   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95906   if (!argp2) {
95907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95908     return ;
95909   }
95910   arg2 = *argp2;
95911   {
95912     try {
95913       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
95914     } catch (std::out_of_range& e) {
95915       {
95916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95917       };
95918     } catch (std::exception& e) {
95919       {
95920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95921       };
95922     } catch (Dali::DaliException e) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95925       };
95926     } catch (...) {
95927       {
95928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95929       };
95930     }
95931   }
95932
95933 }
95934
95935
95936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
95937   void * jresult ;
95938   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
95939
95940   {
95941     try {
95942       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
95943     } catch (std::out_of_range& e) {
95944       {
95945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95946       };
95947     } catch (std::exception& e) {
95948       {
95949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95950       };
95951     } catch (Dali::DaliException e) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95958       };
95959     }
95960   }
95961
95962   jresult = (void *)result;
95963   return jresult;
95964 }
95965
95966
95967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
95968   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95969
95970   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95971   {
95972     try {
95973       delete arg1;
95974     } catch (std::out_of_range& e) {
95975       {
95976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95977       };
95978     } catch (std::exception& e) {
95979       {
95980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (Dali::DaliException e) {
95983       {
95984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95985       };
95986     } catch (...) {
95987       {
95988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95989       };
95990     }
95991   }
95992
95993 }
95994
95995
95996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
95997   unsigned int jresult ;
95998   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
95999   bool result;
96000
96001   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96002   {
96003     try {
96004       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);
96005     } catch (std::out_of_range& e) {
96006       {
96007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96008       };
96009     } catch (std::exception& e) {
96010       {
96011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96012       };
96013     } catch (Dali::DaliException e) {
96014       {
96015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96016       };
96017     } catch (...) {
96018       {
96019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96020       };
96021     }
96022   }
96023
96024   jresult = result;
96025   return jresult;
96026 }
96027
96028
96029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96030   unsigned long jresult ;
96031   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96032   std::size_t result;
96033
96034   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96035   {
96036     try {
96037       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);
96038     } catch (std::out_of_range& e) {
96039       {
96040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96041       };
96042     } catch (std::exception& e) {
96043       {
96044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96045       };
96046     } catch (Dali::DaliException e) {
96047       {
96048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96049       };
96050     } catch (...) {
96051       {
96052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96053       };
96054     }
96055   }
96056
96057   jresult = (unsigned long)result;
96058   return jresult;
96059 }
96060
96061
96062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96063   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96064   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96065
96066   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96067   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96068   {
96069     try {
96070       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96071     } catch (std::out_of_range& e) {
96072       {
96073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (std::exception& e) {
96076       {
96077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96078       };
96079     } catch (Dali::DaliException e) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96082       };
96083     } catch (...) {
96084       {
96085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96086       };
96087     }
96088   }
96089
96090 }
96091
96092
96093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96094   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96095   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96096
96097   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96098   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96099   {
96100     try {
96101       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96102     } catch (std::out_of_range& e) {
96103       {
96104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96105       };
96106     } catch (std::exception& e) {
96107       {
96108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96109       };
96110     } catch (Dali::DaliException e) {
96111       {
96112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96113       };
96114     } catch (...) {
96115       {
96116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96117       };
96118     }
96119   }
96120
96121 }
96122
96123
96124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96125   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96126   Dali::Toolkit::ProgressBar arg2 ;
96127   float arg3 ;
96128   float arg4 ;
96129   Dali::Toolkit::ProgressBar *argp2 ;
96130
96131   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96132   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96133   if (!argp2) {
96134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96135     return ;
96136   }
96137   arg2 = *argp2;
96138   arg3 = (float)jarg3;
96139   arg4 = (float)jarg4;
96140   {
96141     try {
96142       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96143     } catch (std::out_of_range& e) {
96144       {
96145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96146       };
96147     } catch (std::exception& e) {
96148       {
96149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96150       };
96151     } catch (Dali::DaliException e) {
96152       {
96153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96154       };
96155     } catch (...) {
96156       {
96157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96158       };
96159     }
96160   }
96161
96162 }
96163
96164
96165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96166   void * jresult ;
96167   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96168
96169   {
96170     try {
96171       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96172     } catch (std::out_of_range& e) {
96173       {
96174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96175       };
96176     } catch (std::exception& e) {
96177       {
96178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96179       };
96180     } catch (Dali::DaliException e) {
96181       {
96182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96183       };
96184     } catch (...) {
96185       {
96186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96187       };
96188     }
96189   }
96190
96191   jresult = (void *)result;
96192   return jresult;
96193 }
96194
96195
96196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96197   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96198
96199   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96200   {
96201     try {
96202       delete arg1;
96203     } catch (std::out_of_range& e) {
96204       {
96205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96206       };
96207     } catch (std::exception& e) {
96208       {
96209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96210       };
96211     } catch (Dali::DaliException e) {
96212       {
96213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96214       };
96215     } catch (...) {
96216       {
96217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96218       };
96219     }
96220   }
96221
96222 }
96223
96224
96225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96226   unsigned int jresult ;
96227   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96228   bool result;
96229
96230   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96231   {
96232     try {
96233       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);
96234     } catch (std::out_of_range& e) {
96235       {
96236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96237       };
96238     } catch (std::exception& e) {
96239       {
96240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96241       };
96242     } catch (Dali::DaliException e) {
96243       {
96244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96245       };
96246     } catch (...) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96249       };
96250     }
96251   }
96252
96253   jresult = result;
96254   return jresult;
96255 }
96256
96257
96258 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96259   unsigned long jresult ;
96260   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96261   std::size_t result;
96262
96263   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96264   {
96265     try {
96266       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);
96267     } catch (std::out_of_range& e) {
96268       {
96269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96270       };
96271     } catch (std::exception& e) {
96272       {
96273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96274       };
96275     } catch (Dali::DaliException e) {
96276       {
96277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96278       };
96279     } catch (...) {
96280       {
96281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96282       };
96283     }
96284   }
96285
96286   jresult = (unsigned long)result;
96287   return jresult;
96288 }
96289
96290
96291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96292   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96293   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96294
96295   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96296   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96297   {
96298     try {
96299       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96300     } catch (std::out_of_range& e) {
96301       {
96302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96303       };
96304     } catch (std::exception& e) {
96305       {
96306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96307       };
96308     } catch (Dali::DaliException e) {
96309       {
96310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96311       };
96312     } catch (...) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96315       };
96316     }
96317   }
96318
96319 }
96320
96321
96322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96323   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96324   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96325
96326   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96327   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96328   {
96329     try {
96330       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96331     } catch (std::out_of_range& e) {
96332       {
96333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96334       };
96335     } catch (std::exception& e) {
96336       {
96337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96338       };
96339     } catch (Dali::DaliException e) {
96340       {
96341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96342       };
96343     } catch (...) {
96344       {
96345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96346       };
96347     }
96348   }
96349
96350 }
96351
96352
96353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96354   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96355   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96356
96357   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96358   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96359   if (!arg2) {
96360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96361     return ;
96362   }
96363   {
96364     try {
96365       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96366     } catch (std::out_of_range& e) {
96367       {
96368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96369       };
96370     } catch (std::exception& e) {
96371       {
96372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96373       };
96374     } catch (Dali::DaliException e) {
96375       {
96376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96377       };
96378     } catch (...) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96381       };
96382     }
96383   }
96384
96385 }
96386
96387
96388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96389   void * jresult ;
96390   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96391
96392   {
96393     try {
96394       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96395     } catch (std::out_of_range& e) {
96396       {
96397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96398       };
96399     } catch (std::exception& e) {
96400       {
96401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96402       };
96403     } catch (Dali::DaliException e) {
96404       {
96405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96406       };
96407     } catch (...) {
96408       {
96409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96410       };
96411     }
96412   }
96413
96414   jresult = (void *)result;
96415   return jresult;
96416 }
96417
96418
96419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96420   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96421
96422   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96423   {
96424     try {
96425       delete arg1;
96426     } catch (std::out_of_range& e) {
96427       {
96428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96429       };
96430     } catch (std::exception& e) {
96431       {
96432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96433       };
96434     } catch (Dali::DaliException e) {
96435       {
96436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96437       };
96438     } catch (...) {
96439       {
96440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96441       };
96442     }
96443   }
96444
96445 }
96446
96447
96448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96449   unsigned int jresult ;
96450   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96451   bool result;
96452
96453   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96454   {
96455     try {
96456       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96457     } catch (std::out_of_range& e) {
96458       {
96459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96460       };
96461     } catch (std::exception& e) {
96462       {
96463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96464       };
96465     } catch (Dali::DaliException e) {
96466       {
96467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96468       };
96469     } catch (...) {
96470       {
96471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96472       };
96473     }
96474   }
96475
96476   jresult = result;
96477   return jresult;
96478 }
96479
96480
96481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96482   unsigned long jresult ;
96483   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96484   std::size_t result;
96485
96486   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96487   {
96488     try {
96489       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96490     } catch (std::out_of_range& e) {
96491       {
96492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96493       };
96494     } catch (std::exception& e) {
96495       {
96496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96497       };
96498     } catch (Dali::DaliException e) {
96499       {
96500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96501       };
96502     } catch (...) {
96503       {
96504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96505       };
96506     }
96507   }
96508
96509   jresult = (unsigned long)result;
96510   return jresult;
96511 }
96512
96513
96514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96515   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96516   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96517
96518   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96519   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96520   {
96521     try {
96522       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96523     } catch (std::out_of_range& e) {
96524       {
96525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96526       };
96527     } catch (std::exception& e) {
96528       {
96529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96530       };
96531     } catch (Dali::DaliException e) {
96532       {
96533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96534       };
96535     } catch (...) {
96536       {
96537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96538       };
96539     }
96540   }
96541
96542 }
96543
96544
96545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96546   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96547   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96548
96549   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96550   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96551   {
96552     try {
96553       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96554     } catch (std::out_of_range& e) {
96555       {
96556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96557       };
96558     } catch (std::exception& e) {
96559       {
96560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96561       };
96562     } catch (Dali::DaliException e) {
96563       {
96564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96565       };
96566     } catch (...) {
96567       {
96568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96569       };
96570     }
96571   }
96572
96573 }
96574
96575
96576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96577   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96578   Dali::Vector2 *arg2 = 0 ;
96579
96580   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96581   arg2 = (Dali::Vector2 *)jarg2;
96582   if (!arg2) {
96583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96584     return ;
96585   }
96586   {
96587     try {
96588       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96589     } catch (std::out_of_range& e) {
96590       {
96591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96592       };
96593     } catch (std::exception& e) {
96594       {
96595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96596       };
96597     } catch (Dali::DaliException e) {
96598       {
96599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96600       };
96601     } catch (...) {
96602       {
96603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96604       };
96605     }
96606   }
96607
96608 }
96609
96610
96611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96612   void * jresult ;
96613   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96614
96615   {
96616     try {
96617       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96618     } catch (std::out_of_range& e) {
96619       {
96620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96621       };
96622     } catch (std::exception& e) {
96623       {
96624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96625       };
96626     } catch (Dali::DaliException e) {
96627       {
96628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96629       };
96630     } catch (...) {
96631       {
96632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96633       };
96634     }
96635   }
96636
96637   jresult = (void *)result;
96638   return jresult;
96639 }
96640
96641
96642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96643   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96644
96645   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96646   {
96647     try {
96648       delete arg1;
96649     } catch (std::out_of_range& e) {
96650       {
96651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96652       };
96653     } catch (std::exception& e) {
96654       {
96655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (Dali::DaliException e) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96660       };
96661     } catch (...) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96664       };
96665     }
96666   }
96667
96668 }
96669
96670
96671
96672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96673   unsigned int jresult ;
96674   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96675   bool result;
96676
96677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96678   {
96679     try {
96680       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);
96681     } catch (std::out_of_range& e) {
96682       {
96683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96684       };
96685     } catch (std::exception& e) {
96686       {
96687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96688       };
96689     } catch (Dali::DaliException e) {
96690       {
96691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96692       };
96693     } catch (...) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96696       };
96697     }
96698   }
96699
96700   jresult = result;
96701   return jresult;
96702 }
96703
96704
96705 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96706   unsigned long jresult ;
96707   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96708   std::size_t result;
96709
96710   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96711   {
96712     try {
96713       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);
96714     } catch (std::out_of_range& e) {
96715       {
96716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96717       };
96718     } catch (std::exception& e) {
96719       {
96720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (Dali::DaliException e) {
96723       {
96724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96725       };
96726     } catch (...) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96729       };
96730     }
96731   }
96732
96733   jresult = (unsigned long)result;
96734   return jresult;
96735 }
96736
96737
96738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
96739   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96740   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96741
96742   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96743   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96744   {
96745     try {
96746       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96747     } catch (std::out_of_range& e) {
96748       {
96749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96750       };
96751     } catch (std::exception& e) {
96752       {
96753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96754       };
96755     } catch (Dali::DaliException e) {
96756       {
96757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96758       };
96759     } catch (...) {
96760       {
96761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96762       };
96763     }
96764   }
96765
96766 }
96767
96768
96769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
96770   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96771   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96772
96773   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96774   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96775   {
96776     try {
96777       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96778     } catch (std::out_of_range& e) {
96779       {
96780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96781       };
96782     } catch (std::exception& e) {
96783       {
96784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96785       };
96786     } catch (Dali::DaliException e) {
96787       {
96788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96789       };
96790     } catch (...) {
96791       {
96792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96793       };
96794     }
96795   }
96796
96797 }
96798
96799
96800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96801   unsigned int jresult ;
96802   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96803   Dali::Toolkit::Control arg2 ;
96804   Dali::KeyEvent *arg3 = 0 ;
96805   Dali::Toolkit::Control *argp2 ;
96806   bool result;
96807
96808   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96809   argp2 = (Dali::Toolkit::Control *)jarg2;
96810   if (!argp2) {
96811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96812     return 0;
96813   }
96814   arg2 = *argp2;
96815   arg3 = (Dali::KeyEvent *)jarg3;
96816   if (!arg3) {
96817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
96818     return 0;
96819   }
96820   {
96821     try {
96822       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);
96823     } catch (std::out_of_range& e) {
96824       {
96825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96826       };
96827     } catch (std::exception& e) {
96828       {
96829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96830       };
96831     } catch (Dali::DaliException e) {
96832       {
96833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96834       };
96835     } catch (...) {
96836       {
96837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96838       };
96839     }
96840   }
96841
96842   jresult = result;
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
96848   void * jresult ;
96849   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
96850
96851   {
96852     try {
96853       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
96854     } catch (std::out_of_range& e) {
96855       {
96856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96857       };
96858     } catch (std::exception& e) {
96859       {
96860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96861       };
96862     } catch (Dali::DaliException e) {
96863       {
96864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96865       };
96866     } catch (...) {
96867       {
96868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96869       };
96870     }
96871   }
96872
96873   jresult = (void *)result;
96874   return jresult;
96875 }
96876
96877
96878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
96879   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96880
96881   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96882   {
96883     try {
96884       delete arg1;
96885     } catch (std::out_of_range& e) {
96886       {
96887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96888       };
96889     } catch (std::exception& e) {
96890       {
96891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96892       };
96893     } catch (Dali::DaliException e) {
96894       {
96895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96896       };
96897     } catch (...) {
96898       {
96899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96900       };
96901     }
96902   }
96903
96904 }
96905
96906
96907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
96908   unsigned int jresult ;
96909   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96910   bool result;
96911
96912   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96913   {
96914     try {
96915       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
96916     } catch (std::out_of_range& e) {
96917       {
96918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96919       };
96920     } catch (std::exception& e) {
96921       {
96922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96923       };
96924     } catch (Dali::DaliException e) {
96925       {
96926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96927       };
96928     } catch (...) {
96929       {
96930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96931       };
96932     }
96933   }
96934
96935   jresult = result;
96936   return jresult;
96937 }
96938
96939
96940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
96941   unsigned long jresult ;
96942   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96943   std::size_t result;
96944
96945   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96946   {
96947     try {
96948       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
96949     } catch (std::out_of_range& e) {
96950       {
96951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96952       };
96953     } catch (std::exception& e) {
96954       {
96955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96956       };
96957     } catch (Dali::DaliException e) {
96958       {
96959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96960       };
96961     } catch (...) {
96962       {
96963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96964       };
96965     }
96966   }
96967
96968   jresult = (unsigned long)result;
96969   return jresult;
96970 }
96971
96972
96973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
96974   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96975   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
96976
96977   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96978   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
96979   {
96980     try {
96981       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
96982     } catch (std::out_of_range& e) {
96983       {
96984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96985       };
96986     } catch (std::exception& e) {
96987       {
96988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96989       };
96990     } catch (Dali::DaliException e) {
96991       {
96992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96993       };
96994     } catch (...) {
96995       {
96996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96997       };
96998     }
96999   }
97000
97001 }
97002
97003
97004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97005   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97006   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97007
97008   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97009   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97010   {
97011     try {
97012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97013     } catch (std::out_of_range& e) {
97014       {
97015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97016       };
97017     } catch (std::exception& e) {
97018       {
97019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97020       };
97021     } catch (Dali::DaliException e) {
97022       {
97023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97024       };
97025     } catch (...) {
97026       {
97027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97028       };
97029     }
97030   }
97031
97032 }
97033
97034
97035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97036   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97037   Dali::Toolkit::Control arg2 ;
97038   Dali::Toolkit::Control *argp2 ;
97039
97040   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97041   argp2 = (Dali::Toolkit::Control *)jarg2;
97042   if (!argp2) {
97043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97044     return ;
97045   }
97046   arg2 = *argp2;
97047   {
97048     try {
97049       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97050     } catch (std::out_of_range& e) {
97051       {
97052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97053       };
97054     } catch (std::exception& e) {
97055       {
97056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97057       };
97058     } catch (Dali::DaliException e) {
97059       {
97060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97061       };
97062     } catch (...) {
97063       {
97064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97065       };
97066     }
97067   }
97068
97069 }
97070
97071
97072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97073   void * jresult ;
97074   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97075
97076   {
97077     try {
97078       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97079     } catch (std::out_of_range& e) {
97080       {
97081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97082       };
97083     } catch (std::exception& e) {
97084       {
97085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97086       };
97087     } catch (Dali::DaliException e) {
97088       {
97089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97090       };
97091     } catch (...) {
97092       {
97093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97094       };
97095     }
97096   }
97097
97098   jresult = (void *)result;
97099   return jresult;
97100 }
97101
97102
97103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97104   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97105
97106   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97107   {
97108     try {
97109       delete arg1;
97110     } catch (std::out_of_range& e) {
97111       {
97112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97113       };
97114     } catch (std::exception& e) {
97115       {
97116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97117       };
97118     } catch (Dali::DaliException e) {
97119       {
97120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97121       };
97122     } catch (...) {
97123       {
97124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97125       };
97126     }
97127   }
97128
97129 }
97130
97131
97132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97133   unsigned int jresult ;
97134   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97135   bool result;
97136
97137   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97138   {
97139     try {
97140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97141     } catch (std::out_of_range& e) {
97142       {
97143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97144       };
97145     } catch (std::exception& e) {
97146       {
97147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97148       };
97149     } catch (Dali::DaliException e) {
97150       {
97151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97152       };
97153     } catch (...) {
97154       {
97155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97156       };
97157     }
97158   }
97159
97160   jresult = result;
97161   return jresult;
97162 }
97163
97164
97165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97166   unsigned long jresult ;
97167   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97168   std::size_t result;
97169
97170   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97171   {
97172     try {
97173       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97174     } catch (std::out_of_range& e) {
97175       {
97176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97177       };
97178     } catch (std::exception& e) {
97179       {
97180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97181       };
97182     } catch (Dali::DaliException e) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97185       };
97186     } catch (...) {
97187       {
97188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97189       };
97190     }
97191   }
97192
97193   jresult = (unsigned long)result;
97194   return jresult;
97195 }
97196
97197
97198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97199   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97200   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97201
97202   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97203   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97204   {
97205     try {
97206       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97207     } catch (std::out_of_range& e) {
97208       {
97209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97210       };
97211     } catch (std::exception& e) {
97212       {
97213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97214       };
97215     } catch (Dali::DaliException e) {
97216       {
97217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97218       };
97219     } catch (...) {
97220       {
97221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97222       };
97223     }
97224   }
97225
97226 }
97227
97228
97229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97230   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97231   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97232
97233   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97234   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97235   {
97236     try {
97237       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97238     } catch (std::out_of_range& e) {
97239       {
97240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97241       };
97242     } catch (std::exception& e) {
97243       {
97244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97245       };
97246     } catch (Dali::DaliException e) {
97247       {
97248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97249       };
97250     } catch (...) {
97251       {
97252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97253       };
97254     }
97255   }
97256
97257 }
97258
97259
97260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97261   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97262   Dali::Toolkit::VideoView *arg2 = 0 ;
97263
97264   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97265   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97266   if (!arg2) {
97267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97268     return ;
97269   }
97270   {
97271     try {
97272       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97273     } catch (std::out_of_range& e) {
97274       {
97275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97276       };
97277     } catch (std::exception& e) {
97278       {
97279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97280       };
97281     } catch (Dali::DaliException e) {
97282       {
97283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97284       };
97285     } catch (...) {
97286       {
97287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97288       };
97289     }
97290   }
97291
97292 }
97293
97294
97295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97296   void * jresult ;
97297   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97298
97299   {
97300     try {
97301       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97302     } catch (std::out_of_range& e) {
97303       {
97304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97305       };
97306     } catch (std::exception& e) {
97307       {
97308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97309       };
97310     } catch (Dali::DaliException e) {
97311       {
97312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97313       };
97314     } catch (...) {
97315       {
97316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97317       };
97318     }
97319   }
97320
97321   jresult = (void *)result;
97322   return jresult;
97323 }
97324
97325
97326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97327   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97328
97329   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97330   {
97331     try {
97332       delete arg1;
97333     } catch (std::out_of_range& e) {
97334       {
97335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97336       };
97337     } catch (std::exception& e) {
97338       {
97339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97340       };
97341     } catch (Dali::DaliException e) {
97342       {
97343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97344       };
97345     } catch (...) {
97346       {
97347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97348       };
97349     }
97350   }
97351
97352 }
97353
97354
97355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97356   unsigned int jresult ;
97357   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97358   bool result;
97359
97360   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97361   {
97362     try {
97363       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97364     } catch (std::out_of_range& e) {
97365       {
97366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97367       };
97368     } catch (std::exception& e) {
97369       {
97370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97371       };
97372     } catch (Dali::DaliException e) {
97373       {
97374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97375       };
97376     } catch (...) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97379       };
97380     }
97381   }
97382
97383   jresult = result;
97384   return jresult;
97385 }
97386
97387
97388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97389   unsigned long jresult ;
97390   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97391   std::size_t result;
97392
97393   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97394   {
97395     try {
97396       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97397     } catch (std::out_of_range& e) {
97398       {
97399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97400       };
97401     } catch (std::exception& e) {
97402       {
97403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97404       };
97405     } catch (Dali::DaliException e) {
97406       {
97407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97408       };
97409     } catch (...) {
97410       {
97411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97412       };
97413     }
97414   }
97415
97416   jresult = (unsigned long)result;
97417   return jresult;
97418 }
97419
97420
97421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97422   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97423   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97424
97425   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97426   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97427   {
97428     try {
97429       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97430     } catch (std::out_of_range& e) {
97431       {
97432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97433       };
97434     } catch (std::exception& e) {
97435       {
97436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97437       };
97438     } catch (Dali::DaliException e) {
97439       {
97440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97441       };
97442     } catch (...) {
97443       {
97444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97445       };
97446     }
97447   }
97448
97449 }
97450
97451
97452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97453   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97454   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97455
97456   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97457   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97458   {
97459     try {
97460       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97461     } catch (std::out_of_range& e) {
97462       {
97463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97464       };
97465     } catch (std::exception& e) {
97466       {
97467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97468       };
97469     } catch (Dali::DaliException e) {
97470       {
97471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97472       };
97473     } catch (...) {
97474       {
97475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97476       };
97477     }
97478   }
97479
97480 }
97481
97482
97483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97484   unsigned int jresult ;
97485   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97486   Dali::Toolkit::Slider arg2 ;
97487   float arg3 ;
97488   Dali::Toolkit::Slider *argp2 ;
97489   bool result;
97490
97491   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97492   argp2 = (Dali::Toolkit::Slider *)jarg2;
97493   if (!argp2) {
97494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97495     return 0;
97496   }
97497   arg2 = *argp2;
97498   arg3 = (float)jarg3;
97499   {
97500     try {
97501       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97502     } catch (std::out_of_range& e) {
97503       {
97504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97505       };
97506     } catch (std::exception& e) {
97507       {
97508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97509       };
97510     } catch (Dali::DaliException e) {
97511       {
97512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97513       };
97514     } catch (...) {
97515       {
97516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97517       };
97518     }
97519   }
97520
97521   jresult = result;
97522   return jresult;
97523 }
97524
97525
97526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97527   void * jresult ;
97528   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97529
97530   {
97531     try {
97532       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97533     } catch (std::out_of_range& e) {
97534       {
97535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97536       };
97537     } catch (std::exception& e) {
97538       {
97539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97540       };
97541     } catch (Dali::DaliException e) {
97542       {
97543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97544       };
97545     } catch (...) {
97546       {
97547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97548       };
97549     }
97550   }
97551
97552   jresult = (void *)result;
97553   return jresult;
97554 }
97555
97556
97557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97558   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97559
97560   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97561   {
97562     try {
97563       delete arg1;
97564     } catch (std::out_of_range& e) {
97565       {
97566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97567       };
97568     } catch (std::exception& e) {
97569       {
97570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97571       };
97572     } catch (Dali::DaliException e) {
97573       {
97574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97575       };
97576     } catch (...) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97579       };
97580     }
97581   }
97582
97583 }
97584
97585
97586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97587   unsigned int jresult ;
97588   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97589   bool result;
97590
97591   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97592   {
97593     try {
97594       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97595     } catch (std::out_of_range& e) {
97596       {
97597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97598       };
97599     } catch (std::exception& e) {
97600       {
97601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97602       };
97603     } catch (Dali::DaliException e) {
97604       {
97605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97606       };
97607     } catch (...) {
97608       {
97609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97610       };
97611     }
97612   }
97613
97614   jresult = result;
97615   return jresult;
97616 }
97617
97618
97619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97620   unsigned long jresult ;
97621   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97622   std::size_t result;
97623
97624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97625   {
97626     try {
97627       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97628     } catch (std::out_of_range& e) {
97629       {
97630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97631       };
97632     } catch (std::exception& e) {
97633       {
97634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97635       };
97636     } catch (Dali::DaliException e) {
97637       {
97638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97639       };
97640     } catch (...) {
97641       {
97642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97643       };
97644     }
97645   }
97646
97647   jresult = (unsigned long)result;
97648   return jresult;
97649 }
97650
97651
97652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97653   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97654   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97655
97656   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97657   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97658   {
97659     try {
97660       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97661     } catch (std::out_of_range& e) {
97662       {
97663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97664       };
97665     } catch (std::exception& e) {
97666       {
97667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97668       };
97669     } catch (Dali::DaliException e) {
97670       {
97671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97672       };
97673     } catch (...) {
97674       {
97675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97676       };
97677     }
97678   }
97679
97680 }
97681
97682
97683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97684   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97685   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97686
97687   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97688   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97689   {
97690     try {
97691       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97692     } catch (std::out_of_range& e) {
97693       {
97694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97695       };
97696     } catch (std::exception& e) {
97697       {
97698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97699       };
97700     } catch (Dali::DaliException e) {
97701       {
97702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97703       };
97704     } catch (...) {
97705       {
97706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97707       };
97708     }
97709   }
97710
97711 }
97712
97713
97714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97715   unsigned int jresult ;
97716   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97717   Dali::Toolkit::Slider arg2 ;
97718   int arg3 ;
97719   Dali::Toolkit::Slider *argp2 ;
97720   bool result;
97721
97722   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97723   argp2 = (Dali::Toolkit::Slider *)jarg2;
97724   if (!argp2) {
97725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97726     return 0;
97727   }
97728   arg2 = *argp2;
97729   arg3 = (int)jarg3;
97730   {
97731     try {
97732       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97733     } catch (std::out_of_range& e) {
97734       {
97735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97736       };
97737     } catch (std::exception& e) {
97738       {
97739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97740       };
97741     } catch (Dali::DaliException e) {
97742       {
97743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97744       };
97745     } catch (...) {
97746       {
97747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97748       };
97749     }
97750   }
97751
97752   jresult = result;
97753   return jresult;
97754 }
97755
97756
97757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
97758   void * jresult ;
97759   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
97760
97761   {
97762     try {
97763       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
97764     } catch (std::out_of_range& e) {
97765       {
97766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97767       };
97768     } catch (std::exception& e) {
97769       {
97770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97771       };
97772     } catch (Dali::DaliException e) {
97773       {
97774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97775       };
97776     } catch (...) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97779       };
97780     }
97781   }
97782
97783   jresult = (void *)result;
97784   return jresult;
97785 }
97786
97787
97788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
97789   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97790
97791   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97792   {
97793     try {
97794       delete arg1;
97795     } catch (std::out_of_range& e) {
97796       {
97797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97798       };
97799     } catch (std::exception& e) {
97800       {
97801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97802       };
97803     } catch (Dali::DaliException e) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97806       };
97807     } catch (...) {
97808       {
97809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97810       };
97811     }
97812   }
97813
97814 }
97815
97816
97817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
97818   void * jresult ;
97819   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97820
97821   {
97822     try {
97823       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
97824     } catch (std::out_of_range& e) {
97825       {
97826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97827       };
97828     } catch (std::exception& e) {
97829       {
97830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97831       };
97832     } catch (Dali::DaliException e) {
97833       {
97834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97835       };
97836     } catch (...) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97839       };
97840     }
97841   }
97842
97843   jresult = (void *)result;
97844   return jresult;
97845 }
97846
97847
97848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
97849   void * jresult ;
97850   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
97851   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97852
97853   arg1 = (Dali::Toolkit::Ruler *)jarg1;
97854   {
97855     try {
97856       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
97857     } catch (std::out_of_range& e) {
97858       {
97859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97860       };
97861     } catch (std::exception& e) {
97862       {
97863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97864       };
97865     } catch (Dali::DaliException e) {
97866       {
97867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97868       };
97869     } catch (...) {
97870       {
97871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97872       };
97873     }
97874   }
97875
97876   jresult = (void *)result;
97877   return jresult;
97878 }
97879
97880
97881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
97882   void * jresult ;
97883   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
97884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97885
97886   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97887   if (!arg1) {
97888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
97889     return 0;
97890   }
97891   {
97892     try {
97893       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
97894     } catch (std::out_of_range& e) {
97895       {
97896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97897       };
97898     } catch (std::exception& e) {
97899       {
97900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97901       };
97902     } catch (Dali::DaliException e) {
97903       {
97904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97905       };
97906     } catch (...) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97909       };
97910     }
97911   }
97912
97913   jresult = (void *)result;
97914   return jresult;
97915 }
97916
97917
97918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
97919   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97920
97921   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97922   {
97923     try {
97924       delete arg1;
97925     } catch (std::out_of_range& e) {
97926       {
97927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97928       };
97929     } catch (std::exception& e) {
97930       {
97931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97932       };
97933     } catch (Dali::DaliException e) {
97934       {
97935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97936       };
97937     } catch (...) {
97938       {
97939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97940       };
97941     }
97942   }
97943
97944 }
97945
97946
97947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
97948   void * jresult ;
97949   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97950   Dali::Toolkit::Ruler *result = 0 ;
97951
97952   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97953   {
97954     try {
97955       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
97956     } catch (std::out_of_range& e) {
97957       {
97958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97959       };
97960     } catch (std::exception& e) {
97961       {
97962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97963       };
97964     } catch (Dali::DaliException e) {
97965       {
97966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97967       };
97968     } catch (...) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97971       };
97972     }
97973   }
97974
97975   jresult = (void *)result;
97976   return jresult;
97977 }
97978
97979
97980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
97981   void * jresult ;
97982   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97983   Dali::Toolkit::Ruler *result = 0 ;
97984
97985   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97986   {
97987     try {
97988       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
97989     } catch (std::out_of_range& e) {
97990       {
97991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97992       };
97993     } catch (std::exception& e) {
97994       {
97995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97996       };
97997     } catch (Dali::DaliException e) {
97998       {
97999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98000       };
98001     } catch (...) {
98002       {
98003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98004       };
98005     }
98006   }
98007
98008   jresult = (void *)result;
98009   return jresult;
98010 }
98011
98012
98013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98014   void * jresult ;
98015   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98016   Dali::Toolkit::Ruler *result = 0 ;
98017
98018   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98019   {
98020     try {
98021       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98022     } catch (std::out_of_range& e) {
98023       {
98024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98025       };
98026     } catch (std::exception& e) {
98027       {
98028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98029       };
98030     } catch (Dali::DaliException e) {
98031       {
98032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98033       };
98034     } catch (...) {
98035       {
98036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98037       };
98038     }
98039   }
98040
98041   jresult = (void *)result;
98042   return jresult;
98043 }
98044
98045
98046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98047   void * jresult ;
98048   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98049   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98050   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98051
98052   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98053   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98054   if (!arg2) {
98055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98056     return 0;
98057   }
98058   {
98059     try {
98060       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98061     } catch (std::out_of_range& e) {
98062       {
98063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98064       };
98065     } catch (std::exception& e) {
98066       {
98067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98068       };
98069     } catch (Dali::DaliException e) {
98070       {
98071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98072       };
98073     } catch (...) {
98074       {
98075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98076       };
98077     }
98078   }
98079
98080   jresult = (void *)result;
98081   return jresult;
98082 }
98083
98084
98085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98086   void * jresult ;
98087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98088   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98089   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98090
98091   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98092   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98093   {
98094     try {
98095       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98096     } catch (std::out_of_range& e) {
98097       {
98098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98099       };
98100     } catch (std::exception& e) {
98101       {
98102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98103       };
98104     } catch (Dali::DaliException e) {
98105       {
98106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98107       };
98108     } catch (...) {
98109       {
98110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98111       };
98112     }
98113   }
98114
98115   jresult = (void *)result;
98116   return jresult;
98117 }
98118
98119
98120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98121   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98122
98123   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98124   {
98125     try {
98126       (arg1)->Reset();
98127     } catch (std::out_of_range& e) {
98128       {
98129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98130       };
98131     } catch (std::exception& e) {
98132       {
98133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98134       };
98135     } catch (Dali::DaliException e) {
98136       {
98137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98138       };
98139     } catch (...) {
98140       {
98141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98142       };
98143     }
98144   }
98145
98146 }
98147
98148
98149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98150   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98151   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98152
98153   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98154   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98155   {
98156     try {
98157       (arg1)->Reset(arg2);
98158     } catch (std::out_of_range& e) {
98159       {
98160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98161       };
98162     } catch (std::exception& e) {
98163       {
98164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98165       };
98166     } catch (Dali::DaliException e) {
98167       {
98168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98169       };
98170     } catch (...) {
98171       {
98172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98173       };
98174     }
98175   }
98176
98177 }
98178
98179
98180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98181   void * jresult ;
98182   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98183   Dali::Toolkit::Ruler *result = 0 ;
98184
98185   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98186   {
98187     try {
98188       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98189     } catch (std::out_of_range& e) {
98190       {
98191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98192       };
98193     } catch (std::exception& e) {
98194       {
98195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98196       };
98197     } catch (Dali::DaliException e) {
98198       {
98199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98200       };
98201     } catch (...) {
98202       {
98203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98204       };
98205     }
98206   }
98207
98208   jresult = (void *)result;
98209   return jresult;
98210 }
98211
98212
98213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98214   float jresult ;
98215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98216   float arg2 ;
98217   float arg3 ;
98218   float result;
98219
98220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98221   arg2 = (float)jarg2;
98222   arg3 = (float)jarg3;
98223   {
98224     try {
98225       result = (float)(*arg1)->Snap(arg2,arg3);
98226     } catch (std::out_of_range& e) {
98227       {
98228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98229       };
98230     } catch (std::exception& e) {
98231       {
98232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98233       };
98234     } catch (Dali::DaliException e) {
98235       {
98236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98237       };
98238     } catch (...) {
98239       {
98240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98241       };
98242     }
98243   }
98244
98245   jresult = result;
98246   return jresult;
98247 }
98248
98249
98250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98251   float jresult ;
98252   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98253   float arg2 ;
98254   float result;
98255
98256   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98257   arg2 = (float)jarg2;
98258   {
98259     try {
98260       result = (float)(*arg1)->Snap(arg2);
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 = result;
98281   return jresult;
98282 }
98283
98284
98285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98286   float jresult ;
98287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98288   unsigned int arg2 ;
98289   unsigned int *arg3 = 0 ;
98290   bool arg4 ;
98291   float result;
98292
98293   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98294   arg2 = (unsigned int)jarg2;
98295   arg3 = (unsigned int *)jarg3;
98296   arg4 = jarg4 ? true : false;
98297   {
98298     try {
98299       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98300     } catch (std::out_of_range& e) {
98301       {
98302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98303       };
98304     } catch (std::exception& e) {
98305       {
98306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98307       };
98308     } catch (Dali::DaliException e) {
98309       {
98310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98311       };
98312     } catch (...) {
98313       {
98314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98315       };
98316     }
98317   }
98318
98319   jresult = result;
98320   return jresult;
98321 }
98322
98323
98324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98325   unsigned int jresult ;
98326   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98327   float arg2 ;
98328   bool arg3 ;
98329   unsigned int result;
98330
98331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98332   arg2 = (float)jarg2;
98333   arg3 = jarg3 ? true : false;
98334   {
98335     try {
98336       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98337     } catch (std::out_of_range& e) {
98338       {
98339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98340       };
98341     } catch (std::exception& e) {
98342       {
98343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98344       };
98345     } catch (Dali::DaliException e) {
98346       {
98347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98348       };
98349     } catch (...) {
98350       {
98351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98352       };
98353     }
98354   }
98355
98356   jresult = result;
98357   return jresult;
98358 }
98359
98360
98361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98362   unsigned int jresult ;
98363   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98364   unsigned int result;
98365
98366   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98367   {
98368     try {
98369       result = (unsigned int)(*arg1)->GetTotalPages();
98370     } catch (std::out_of_range& e) {
98371       {
98372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98373       };
98374     } catch (std::exception& e) {
98375       {
98376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98377       };
98378     } catch (Dali::DaliException e) {
98379       {
98380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98381       };
98382     } catch (...) {
98383       {
98384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98385       };
98386     }
98387   }
98388
98389   jresult = result;
98390   return jresult;
98391 }
98392
98393
98394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98395   int jresult ;
98396   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98397   Dali::Toolkit::Ruler::RulerType result;
98398
98399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98400   {
98401     try {
98402       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98403     } catch (std::out_of_range& e) {
98404       {
98405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98406       };
98407     } catch (std::exception& e) {
98408       {
98409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98410       };
98411     } catch (Dali::DaliException e) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98414       };
98415     } catch (...) {
98416       {
98417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98418       };
98419     }
98420   }
98421
98422   jresult = (int)result;
98423   return jresult;
98424 }
98425
98426
98427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98428   unsigned int jresult ;
98429   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98430   bool result;
98431
98432   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98433   {
98434     try {
98435       result = (bool)(*arg1)->IsEnabled();
98436     } catch (std::out_of_range& e) {
98437       {
98438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98439       };
98440     } catch (std::exception& e) {
98441       {
98442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98443       };
98444     } catch (Dali::DaliException e) {
98445       {
98446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98447       };
98448     } catch (...) {
98449       {
98450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98451       };
98452     }
98453   }
98454
98455   jresult = result;
98456   return jresult;
98457 }
98458
98459
98460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98461   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98462
98463   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98464   {
98465     try {
98466       (*arg1)->Enable();
98467     } catch (std::out_of_range& e) {
98468       {
98469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98470       };
98471     } catch (std::exception& e) {
98472       {
98473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98474       };
98475     } catch (Dali::DaliException e) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98478       };
98479     } catch (...) {
98480       {
98481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98482       };
98483     }
98484   }
98485
98486 }
98487
98488
98489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98490   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98491
98492   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98493   {
98494     try {
98495       (*arg1)->Disable();
98496     } catch (std::out_of_range& e) {
98497       {
98498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98499       };
98500     } catch (std::exception& e) {
98501       {
98502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98503       };
98504     } catch (Dali::DaliException e) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98507       };
98508     } catch (...) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98511       };
98512     }
98513   }
98514
98515 }
98516
98517
98518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98520   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98521   Dali::Toolkit::RulerDomain *argp2 ;
98522
98523   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98524   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98525   if (!argp2) {
98526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98527     return ;
98528   }
98529   arg2 = *argp2;
98530   {
98531     try {
98532       (*arg1)->SetDomain(arg2);
98533     } catch (std::out_of_range& e) {
98534       {
98535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98536       };
98537     } catch (std::exception& e) {
98538       {
98539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98540       };
98541     } catch (Dali::DaliException e) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98544       };
98545     } catch (...) {
98546       {
98547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98548       };
98549     }
98550   }
98551
98552 }
98553
98554
98555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98556   void * jresult ;
98557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98558   Dali::Toolkit::RulerDomain *result = 0 ;
98559
98560   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98561   {
98562     try {
98563       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98564     } catch (std::out_of_range& e) {
98565       {
98566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98567       };
98568     } catch (std::exception& e) {
98569       {
98570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98571       };
98572     } catch (Dali::DaliException e) {
98573       {
98574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98575       };
98576     } catch (...) {
98577       {
98578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98579       };
98580     }
98581   }
98582
98583   jresult = (void *)result;
98584   return jresult;
98585 }
98586
98587
98588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98589   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98590
98591   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98592   {
98593     try {
98594       (*arg1)->DisableDomain();
98595     } catch (std::out_of_range& e) {
98596       {
98597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98598       };
98599     } catch (std::exception& e) {
98600       {
98601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98602       };
98603     } catch (Dali::DaliException e) {
98604       {
98605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98606       };
98607     } catch (...) {
98608       {
98609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98610       };
98611     }
98612   }
98613
98614 }
98615
98616
98617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98618   float jresult ;
98619   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98620   float arg2 ;
98621   float arg3 ;
98622   float arg4 ;
98623   float result;
98624
98625   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98626   arg2 = (float)jarg2;
98627   arg3 = (float)jarg3;
98628   arg4 = (float)jarg4;
98629   {
98630     try {
98631       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98632     } catch (std::out_of_range& e) {
98633       {
98634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98635       };
98636     } catch (std::exception& e) {
98637       {
98638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98639       };
98640     } catch (Dali::DaliException e) {
98641       {
98642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98643       };
98644     } catch (...) {
98645       {
98646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98647       };
98648     }
98649   }
98650
98651   jresult = result;
98652   return jresult;
98653 }
98654
98655
98656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98657   float jresult ;
98658   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98659   float arg2 ;
98660   float arg3 ;
98661   float result;
98662
98663   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98664   arg2 = (float)jarg2;
98665   arg3 = (float)jarg3;
98666   {
98667     try {
98668       result = (float)(*arg1)->Clamp(arg2,arg3);
98669     } catch (std::out_of_range& e) {
98670       {
98671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98672       };
98673     } catch (std::exception& e) {
98674       {
98675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98676       };
98677     } catch (Dali::DaliException e) {
98678       {
98679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98680       };
98681     } catch (...) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98684       };
98685     }
98686   }
98687
98688   jresult = result;
98689   return jresult;
98690 }
98691
98692
98693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98694   float jresult ;
98695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98696   float arg2 ;
98697   float result;
98698
98699   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98700   arg2 = (float)jarg2;
98701   {
98702     try {
98703       result = (float)(*arg1)->Clamp(arg2);
98704     } catch (std::out_of_range& e) {
98705       {
98706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98707       };
98708     } catch (std::exception& e) {
98709       {
98710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98711       };
98712     } catch (Dali::DaliException e) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98715       };
98716     } catch (...) {
98717       {
98718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98719       };
98720     }
98721   }
98722
98723   jresult = result;
98724   return jresult;
98725 }
98726
98727
98728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98729   float jresult ;
98730   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98731   float arg2 ;
98732   float arg3 ;
98733   float arg4 ;
98734   Dali::Toolkit::ClampState *arg5 = 0 ;
98735   float result;
98736
98737   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98738   arg2 = (float)jarg2;
98739   arg3 = (float)jarg3;
98740   arg4 = (float)jarg4;
98741   arg5 = (Dali::Toolkit::ClampState *)jarg5;
98742   if (!arg5) {
98743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98744     return 0;
98745   }
98746   {
98747     try {
98748       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
98749     } catch (std::out_of_range& e) {
98750       {
98751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98752       };
98753     } catch (std::exception& e) {
98754       {
98755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98756       };
98757     } catch (Dali::DaliException e) {
98758       {
98759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98760       };
98761     } catch (...) {
98762       {
98763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98764       };
98765     }
98766   }
98767
98768   jresult = result;
98769   return jresult;
98770 }
98771
98772
98773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
98774   float jresult ;
98775   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98776   float arg2 ;
98777   float arg3 ;
98778   float arg4 ;
98779   float arg5 ;
98780   float result;
98781
98782   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98783   arg2 = (float)jarg2;
98784   arg3 = (float)jarg3;
98785   arg4 = (float)jarg4;
98786   arg5 = (float)jarg5;
98787   {
98788     try {
98789       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
98790     } catch (std::out_of_range& e) {
98791       {
98792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98793       };
98794     } catch (std::exception& e) {
98795       {
98796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98797       };
98798     } catch (Dali::DaliException e) {
98799       {
98800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98801       };
98802     } catch (...) {
98803       {
98804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98805       };
98806     }
98807   }
98808
98809   jresult = result;
98810   return jresult;
98811 }
98812
98813
98814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
98815   float jresult ;
98816   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98817   float arg2 ;
98818   float arg3 ;
98819   float arg4 ;
98820   float result;
98821
98822   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98823   arg2 = (float)jarg2;
98824   arg3 = (float)jarg3;
98825   arg4 = (float)jarg4;
98826   {
98827     try {
98828       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
98829     } catch (std::out_of_range& e) {
98830       {
98831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98832       };
98833     } catch (std::exception& e) {
98834       {
98835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98836       };
98837     } catch (Dali::DaliException e) {
98838       {
98839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98840       };
98841     } catch (...) {
98842       {
98843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98844       };
98845     }
98846   }
98847
98848   jresult = result;
98849   return jresult;
98850 }
98851
98852
98853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
98854   float jresult ;
98855   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98856   float arg2 ;
98857   float arg3 ;
98858   float result;
98859
98860   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98861   arg2 = (float)jarg2;
98862   arg3 = (float)jarg3;
98863   {
98864     try {
98865       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
98866     } catch (std::out_of_range& e) {
98867       {
98868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98869       };
98870     } catch (std::exception& e) {
98871       {
98872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98873       };
98874     } catch (Dali::DaliException e) {
98875       {
98876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98877       };
98878     } catch (...) {
98879       {
98880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98881       };
98882     }
98883   }
98884
98885   jresult = result;
98886   return jresult;
98887 }
98888
98889
98890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
98891   float jresult ;
98892   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98893   float arg2 ;
98894   float result;
98895
98896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98897   arg2 = (float)jarg2;
98898   {
98899     try {
98900       result = (float)(*arg1)->SnapAndClamp(arg2);
98901     } catch (std::out_of_range& e) {
98902       {
98903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98904       };
98905     } catch (std::exception& e) {
98906       {
98907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98908       };
98909     } catch (Dali::DaliException e) {
98910       {
98911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98912       };
98913     } catch (...) {
98914       {
98915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98916       };
98917     }
98918   }
98919
98920   jresult = result;
98921   return jresult;
98922 }
98923
98924
98925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
98926   float jresult ;
98927   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98928   float arg2 ;
98929   float arg3 ;
98930   float arg4 ;
98931   float arg5 ;
98932   Dali::Toolkit::ClampState *arg6 = 0 ;
98933   float result;
98934
98935   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98936   arg2 = (float)jarg2;
98937   arg3 = (float)jarg3;
98938   arg4 = (float)jarg4;
98939   arg5 = (float)jarg5;
98940   arg6 = (Dali::Toolkit::ClampState *)jarg6;
98941   if (!arg6) {
98942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98943     return 0;
98944   }
98945   {
98946     try {
98947       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
98948     } catch (std::out_of_range& e) {
98949       {
98950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98951       };
98952     } catch (std::exception& e) {
98953       {
98954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98955       };
98956     } catch (Dali::DaliException e) {
98957       {
98958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98959       };
98960     } catch (...) {
98961       {
98962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98963       };
98964     }
98965   }
98966
98967   jresult = result;
98968   return jresult;
98969 }
98970
98971
98972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
98973   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98974
98975   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98976   {
98977     try {
98978       (*arg1)->Reference();
98979     } catch (std::out_of_range& e) {
98980       {
98981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98982       };
98983     } catch (std::exception& e) {
98984       {
98985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98986       };
98987     } catch (Dali::DaliException e) {
98988       {
98989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98990       };
98991     } catch (...) {
98992       {
98993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98994       };
98995     }
98996   }
98997
98998 }
98999
99000
99001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99002   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99003
99004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99005   {
99006     try {
99007       (*arg1)->Unreference();
99008     } catch (std::out_of_range& e) {
99009       {
99010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99011       };
99012     } catch (std::exception& e) {
99013       {
99014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99015       };
99016     } catch (Dali::DaliException e) {
99017       {
99018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99019       };
99020     } catch (...) {
99021       {
99022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99023       };
99024     }
99025   }
99026
99027 }
99028
99029
99030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99031   int jresult ;
99032   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99033   int result;
99034
99035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99036   {
99037     try {
99038       result = (int)(*arg1)->ReferenceCount();
99039     } catch (std::out_of_range& e) {
99040       {
99041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99042       };
99043     } catch (std::exception& e) {
99044       {
99045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99046       };
99047     } catch (Dali::DaliException e) {
99048       {
99049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99050       };
99051     } catch (...) {
99052       {
99053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99054       };
99055     }
99056   }
99057
99058   jresult = result;
99059   return jresult;
99060 }
99061
99062
99063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99064   unsigned int jresult ;
99065   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99066   bool result;
99067
99068   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99069   {
99070     try {
99071       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99072     } catch (std::out_of_range& e) {
99073       {
99074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99075       };
99076     } catch (std::exception& e) {
99077       {
99078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99079       };
99080     } catch (Dali::DaliException e) {
99081       {
99082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99083       };
99084     } catch (...) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99087       };
99088     }
99089   }
99090
99091   jresult = result;
99092   return jresult;
99093 }
99094
99095
99096 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99097   unsigned long jresult ;
99098   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99099   std::size_t result;
99100
99101   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99102   {
99103     try {
99104       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99105     } catch (std::out_of_range& e) {
99106       {
99107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99108       };
99109     } catch (std::exception& e) {
99110       {
99111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99112       };
99113     } catch (Dali::DaliException e) {
99114       {
99115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99116       };
99117     } catch (...) {
99118       {
99119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99120       };
99121     }
99122   }
99123
99124   jresult = (unsigned long)result;
99125   return jresult;
99126 }
99127
99128
99129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99130   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99131   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99132
99133   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99134   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99135   {
99136     try {
99137       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99138     } catch (std::out_of_range& e) {
99139       {
99140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99141       };
99142     } catch (std::exception& e) {
99143       {
99144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99145       };
99146     } catch (Dali::DaliException e) {
99147       {
99148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99149       };
99150     } catch (...) {
99151       {
99152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99153       };
99154     }
99155   }
99156
99157 }
99158
99159
99160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99161   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99162   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99163
99164   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99165   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99166   {
99167     try {
99168       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99169     } catch (std::out_of_range& e) {
99170       {
99171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99172       };
99173     } catch (std::exception& e) {
99174       {
99175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99176       };
99177     } catch (Dali::DaliException e) {
99178       {
99179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99180       };
99181     } catch (...) {
99182       {
99183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99184       };
99185     }
99186   }
99187
99188 }
99189
99190
99191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99192   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99193   Dali::Toolkit::Control arg2 ;
99194   Dali::Toolkit::Control *argp2 ;
99195
99196   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99197   argp2 = (Dali::Toolkit::Control *)jarg2;
99198   if (!argp2) {
99199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99200     return ;
99201   }
99202   arg2 = *argp2;
99203   {
99204     try {
99205       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99206     } catch (std::out_of_range& e) {
99207       {
99208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99209       };
99210     } catch (std::exception& e) {
99211       {
99212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99213       };
99214     } catch (Dali::DaliException e) {
99215       {
99216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99217       };
99218     } catch (...) {
99219       {
99220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99221       };
99222     }
99223   }
99224
99225 }
99226
99227
99228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99229   void * jresult ;
99230   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99231
99232   {
99233     try {
99234       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99235     } catch (std::out_of_range& e) {
99236       {
99237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99238       };
99239     } catch (std::exception& e) {
99240       {
99241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99242       };
99243     } catch (Dali::DaliException e) {
99244       {
99245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99246       };
99247     } catch (...) {
99248       {
99249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99250       };
99251     }
99252   }
99253
99254   jresult = (void *)result;
99255   return jresult;
99256 }
99257
99258
99259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99260   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99261
99262   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99263   {
99264     try {
99265       delete arg1;
99266     } catch (std::out_of_range& e) {
99267       {
99268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99269       };
99270     } catch (std::exception& e) {
99271       {
99272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99273       };
99274     } catch (Dali::DaliException e) {
99275       {
99276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99277       };
99278     } catch (...) {
99279       {
99280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99281       };
99282     }
99283   }
99284
99285 }
99286
99287 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99288   Dali::RefObject *result = NULL;
99289
99290   if (arg1)
99291   {
99292     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99293   }
99294   return result;
99295 }
99296
99297 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99298     return (Dali::RefObject *)jarg1;
99299 }
99300
99301 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99302     return (Dali::SignalObserver *)jarg1;
99303 }
99304
99305 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99306     return (Dali::ConnectionTrackerInterface *)jarg1;
99307 }
99308
99309 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99310     return (Dali::BaseHandle *)jarg1;
99311 }
99312
99313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99314     return (Dali::BaseHandle *)jarg1;
99315 }
99316
99317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99318     return (Dali::BaseHandle *)jarg1;
99319 }
99320
99321 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99322     return (Dali::BaseHandle *)jarg1;
99323 }
99324
99325 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99326     return (Dali::BaseHandle *)jarg1;
99327 }
99328
99329 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99330     return (Dali::BaseHandle *)jarg1;
99331 }
99332
99333 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99334     return (Dali::BaseHandle *)jarg1;
99335 }
99336
99337 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99338     return (Dali::BaseHandle *)jarg1;
99339 }
99340
99341 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99342     return (Dali::BaseHandle *)jarg1;
99343 }
99344
99345 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99346     return (Dali::BaseHandle *)jarg1;
99347 }
99348
99349 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99350     return (Dali::BaseHandle *)jarg1;
99351 }
99352
99353 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99354     return (Dali::BaseHandle *)jarg1;
99355 }
99356
99357 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99358     return (Dali::BaseHandle *)jarg1;
99359 }
99360
99361 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99362     return (Dali::Handle *)jarg1;
99363 }
99364
99365 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99366     return (Dali::Handle *)jarg1;
99367 }
99368
99369 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99370     return (Dali::BaseHandle *)jarg1;
99371 }
99372
99373 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99374     return (Dali::BaseHandle *)jarg1;
99375 }
99376
99377 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99378     return (Dali::Handle *)jarg1;
99379 }
99380
99381 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99382     return (Dali::BaseHandle *)jarg1;
99383 }
99384
99385 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99386     return (Dali::Handle *)jarg1;
99387 }
99388
99389 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99390     return (Dali::GestureDetector *)jarg1;
99391 }
99392
99393 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99394     return (Dali::Gesture *)jarg1;
99395 }
99396
99397 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99398     return (Dali::Handle *)jarg1;
99399 }
99400
99401 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99402     return (Dali::Actor *)jarg1;
99403 }
99404
99405 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99406     return (Dali::BaseHandle *)jarg1;
99407 }
99408
99409 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99410     return (Dali::RefObject *)jarg1;
99411 }
99412
99413 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99414     return (Dali::Actor *)jarg1;
99415 }
99416
99417 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99418     return (Dali::GestureDetector *)jarg1;
99419 }
99420
99421 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99422     return (Dali::Gesture *)jarg1;
99423 }
99424
99425 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99426     return (Dali::GestureDetector *)jarg1;
99427 }
99428
99429 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99430     return (Dali::Gesture *)jarg1;
99431 }
99432
99433 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99434     return (Dali::GestureDetector *)jarg1;
99435 }
99436
99437 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99438     return (Dali::Gesture *)jarg1;
99439 }
99440
99441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99442     return (Dali::BaseHandle *)jarg1;
99443 }
99444
99445 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99446     return (Dali::Handle *)jarg1;
99447 }
99448
99449 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99450     return (Dali::Handle *)jarg1;
99451 }
99452
99453 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99454     return (Dali::Handle *)jarg1;
99455 }
99456
99457 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99458     return (Dali::Image *)jarg1;
99459 }
99460
99461 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99462     return (Dali::Image *)jarg1;
99463 }
99464
99465 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99466     return (Dali::RefObject *)jarg1;
99467 }
99468
99469 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99470     return (Dali::Image *)jarg1;
99471 }
99472
99473 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99474     return (Dali::Image *)jarg1;
99475 }
99476
99477 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99478     return (Dali::ResourceImage *)jarg1;
99479 }
99480
99481 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99482     return (Dali::Actor *)jarg1;
99483 }
99484
99485 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99486     return (Dali::BaseHandle *)jarg1;
99487 }
99488
99489 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99490     return (Dali::BaseHandle *)jarg1;
99491 }
99492
99493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99494     return (Dali::BaseHandle *)jarg1;
99495 }
99496
99497 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99498     return (Dali::CustomActorImpl *)jarg1;
99499 }
99500
99501 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99502     return (Dali::CustomActor *)jarg1;
99503 }
99504
99505 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99506     return (Dali::BaseHandle *)jarg1;
99507 }
99508
99509 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99510     return (Dali::Toolkit::Control *)jarg1;
99511 }
99512
99513 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99514     return (Dali::Toolkit::Control *)jarg1;
99515 }
99516
99517 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99518     return (Dali::Toolkit::Button *)jarg1;
99519 }
99520
99521 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99522     return (Dali::Toolkit::Button *)jarg1;
99523 }
99524
99525 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99526     return (Dali::Toolkit::Button *)jarg1;
99527 }
99528
99529 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99530     return (Dali::Toolkit::Control *)jarg1;
99531 }
99532
99533 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99534     return (Dali::Toolkit::Control *)jarg1;
99535 }
99536
99537 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99538     return (Dali::Toolkit::Control *)jarg1;
99539 }
99540
99541 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99542     return (Dali::Toolkit::Control *)jarg1;
99543 }
99544
99545 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99546     return (Dali::Toolkit::Control *)jarg1;
99547 }
99548
99549 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99550     return (Dali::RefObject *)jarg1;
99551 }
99552
99553 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99554     return (Dali::Toolkit::Scrollable *)jarg1;
99555 }
99556
99557 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99558     return (Dali::BaseHandle *)jarg1;
99559 }
99560
99561 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99562     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99563 }
99564
99565 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99566     return (Dali::RefObject *)jarg1;
99567 }
99568
99569 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99570     return (Dali::Toolkit::Ruler *)jarg1;
99571 }
99572
99573 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99574     return (Dali::Toolkit::Ruler *)jarg1;
99575 }
99576
99577 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99578     return (Dali::Toolkit::Scrollable *)jarg1;
99579 }
99580
99581 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99582     return (Dali::Toolkit::Control *)jarg1;
99583 }
99584
99585
99586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99587     return (Dali::Toolkit::Control *)jarg1;
99588 }
99589
99590 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99591     return (Dali::BaseHandle *)jarg1;
99592 }
99593
99594 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99595     return (Dali::BaseHandle *)jarg1;
99596 }
99597
99598 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99599     return (Dali::Toolkit::Control *)jarg1;
99600 }
99601
99602 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99603     return (Dali::Toolkit::Control *)jarg1;
99604 }
99605
99606 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99607     return (Dali::Toolkit::Control *)jarg1;
99608 }
99609
99610 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99611     return (Dali::Toolkit::Control *)jarg1;
99612 }
99613
99614 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99615     return (Dali::Toolkit::Control *)jarg1;
99616 }
99617
99618 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99619     return (Dali::Toolkit::Control *)jarg1;
99620 }
99621
99622 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99623     return (Dali::Toolkit::PageTurnView *)jarg1;
99624 }
99625
99626 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99627     return (Dali::Toolkit::PageTurnView *)jarg1;
99628 }
99629
99630 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99631     return (Dali::Toolkit::Button *)jarg1;
99632 }
99633
99634 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99635     return (Dali::BaseHandle *)jarg1;
99636 }
99637
99638 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99639     return (Dali::BaseHandle *)jarg1;
99640 }
99641
99642 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99643     return (Dali::BaseHandle *)jarg1;
99644 }
99645
99646 /*
99647  * Widget binding
99648  */
99649 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99650     return (Dali::BaseHandle *)jarg1;
99651 }
99652
99653 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99654     return (Dali::BaseObject *)jarg1;
99655 }
99656
99657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99658   void * jresult ;
99659   Dali::Widget result;
99660
99661   {
99662     try {
99663       result = Dali::Widget::New();
99664     } catch (std::out_of_range& e) {
99665       {
99666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99667       };
99668     } catch (std::exception& e) {
99669       {
99670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99671       };
99672     } catch (...) {
99673       {
99674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99675       };
99676     }
99677   }
99678   jresult = new Dali::Widget((const Dali::Widget &)result);
99679   return jresult;
99680 }
99681
99682
99683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99684   void * jresult ;
99685   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99686   Dali::Widget result;
99687
99688   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99689
99690   if (!arg1) {
99691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99692     return 0;
99693   }
99694   {
99695     try {
99696       jresult = new Dali::Widget(arg1);
99697     } catch (std::out_of_range& e) {
99698       {
99699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99700       };
99701     } catch (std::exception& e) {
99702       {
99703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99704       };
99705     } catch (...) {
99706       {
99707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99708       };
99709     }
99710   }
99711   return jresult;
99712 }
99713
99714
99715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99716   void * jresult ;
99717   Dali::Widget *result = 0 ;
99718
99719   {
99720     try {
99721       result = (Dali::Widget *)new Dali::Widget();
99722     } catch (std::out_of_range& e) {
99723       {
99724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99725       };
99726     } catch (std::exception& e) {
99727       {
99728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99729       };
99730     } catch (...) {
99731       {
99732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99733       };
99734     }
99735   }
99736   jresult = (void *)result;
99737   return jresult;
99738 }
99739
99740
99741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
99742   void * jresult ;
99743   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99744   Dali::Widget *arg2 = 0 ;
99745   Dali::Widget *result = 0 ;
99746
99747   arg1 = (Dali::Widget *)jarg1;
99748   arg2 = (Dali::Widget *)jarg2;
99749   if (!arg2) {
99750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
99751     return 0;
99752   }
99753   {
99754     try {
99755       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
99756     } catch (std::out_of_range& e) {
99757       {
99758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99759       };
99760     } catch (std::exception& e) {
99761       {
99762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99763       };
99764     } catch (...) {
99765       {
99766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99767       };
99768     }
99769   }
99770   jresult = (void *)result;
99771   return jresult;
99772 }
99773
99774
99775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
99776   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99777
99778   arg1 = (Dali::Widget *)jarg1;
99779   {
99780     try {
99781       delete arg1;
99782     } catch (std::out_of_range& e) {
99783       {
99784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99785       };
99786     } catch (std::exception& e) {
99787       {
99788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99789       };
99790     } catch (...) {
99791       {
99792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99793       };
99794     }
99795   }
99796 }
99797
99798
99799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
99800   void * jresult ;
99801   SwigDirector_WidgetImpl* result;
99802   {
99803     try {
99804       result = new SwigDirector_WidgetImpl();
99805     } catch (std::out_of_range& e) {
99806       {
99807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99808       };
99809     } catch (std::exception& e) {
99810       {
99811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99812       };
99813     } catch (...) {
99814       {
99815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99816       };
99817     }
99818   }
99819   jresult = result;
99820   return jresult;
99821 }
99822
99823
99824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
99825   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99826   std::string *arg2 = 0 ;
99827   Dali::Window arg3 ;
99828   Dali::Window *argp3 ;
99829
99830   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99831   if (!jarg2) {
99832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99833     return ;
99834   }
99835   std::string arg2_str(jarg2);
99836   arg2 = &arg2_str;
99837   argp3 = (Dali::Window *)jarg3;
99838   if (!argp3) {
99839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99840     return ;
99841   }
99842   arg3 = *argp3;
99843   {
99844     try {
99845       (arg1)->OnCreate((std::string const &)*arg2,arg3);
99846     } catch (std::out_of_range& e) {
99847       {
99848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99849       };
99850     } catch (std::exception& e) {
99851       {
99852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99853       };
99854     } catch (...) {
99855       {
99856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99857       };
99858     }
99859   }
99860 }
99861
99862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
99863   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99864   std::string *arg2 = 0 ;
99865   Dali::Window arg3 ;
99866   Dali::Window *argp3 ;
99867
99868   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99869   if (!jarg2) {
99870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99871     return ;
99872   }
99873   std::string arg2_str(jarg2);
99874   arg2 = &arg2_str;
99875   argp3 = (Dali::Window *)jarg3;
99876   if (!argp3) {
99877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99878     return ;
99879   }
99880   arg3 = *argp3;
99881   {
99882     try {
99883       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
99884     } catch (std::out_of_range& e) {
99885       {
99886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99887       };
99888     } catch (std::exception& e) {
99889       {
99890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99891       };
99892     } catch (...) {
99893       {
99894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99895       };
99896     }
99897   }
99898 }
99899
99900
99901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
99902   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99903   std::string *arg2 = 0 ;
99904   Dali::Widget::Termination arg3 ;
99905
99906   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99907   if (!jarg2) {
99908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99909     return ;
99910   }
99911   std::string arg2_str(jarg2);
99912   arg2 = &arg2_str;
99913   arg3 = (Dali::Widget::Termination)jarg3;
99914   {
99915     try {
99916       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
99917     } catch (std::out_of_range& e) {
99918       {
99919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99920       };
99921     } catch (std::exception& e) {
99922       {
99923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99924       };
99925     } catch (...) {
99926       {
99927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99928       };
99929     }
99930   }
99931 }
99932
99933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
99934   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99935   std::string *arg2 = 0 ;
99936   Dali::Widget::Termination arg3 ;
99937
99938   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99939   if (!jarg2) {
99940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99941     return ;
99942   }
99943   std::string arg2_str(jarg2);
99944   arg2 = &arg2_str;
99945   arg3 = (Dali::Widget::Termination)jarg3;
99946   {
99947     try {
99948       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
99949     } catch (std::out_of_range& e) {
99950       {
99951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99952       };
99953     } catch (std::exception& e) {
99954       {
99955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99956       };
99957     } catch (...) {
99958       {
99959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99960       };
99961     }
99962   }
99963 }
99964
99965
99966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
99967   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99968
99969   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99970   {
99971     try {
99972       (arg1)->OnPause();
99973     } catch (std::out_of_range& e) {
99974       {
99975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99976       };
99977     } catch (std::exception& e) {
99978       {
99979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99980       };
99981     } catch (...) {
99982       {
99983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99984       };
99985     }
99986   }
99987 }
99988
99989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
99990   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99991
99992   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99993   {
99994     try {
99995       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
99996     } catch (std::out_of_range& e) {
99997       {
99998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99999       };
100000     } catch (std::exception& e) {
100001       {
100002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100003       };
100004     } catch (...) {
100005       {
100006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100007       };
100008     }
100009   }
100010 }
100011
100012
100013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100014   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100015
100016   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100017   {
100018     try {
100019       (arg1)->OnResume();
100020     } catch (std::out_of_range& e) {
100021       {
100022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100023       };
100024     } catch (std::exception& e) {
100025       {
100026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100027       };
100028     } catch (...) {
100029       {
100030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100031       };
100032     }
100033   }
100034 }
100035
100036
100037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100038   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100039
100040   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100041   {
100042     try {
100043       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100044     } catch (std::out_of_range& e) {
100045       {
100046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100047       };
100048     } catch (std::exception& e) {
100049       {
100050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100051       };
100052     } catch (...) {
100053       {
100054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100055       };
100056     }
100057   }
100058 }
100059
100060
100061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100062   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100063   Dali::Window arg2 ;
100064   Dali::Window *argp2 ;
100065
100066   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100067   argp2 = (Dali::Window *)jarg2;
100068   if (!argp2) {
100069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100070     return ;
100071   }
100072   arg2 = *argp2;
100073   {
100074     try {
100075       (arg1)->OnResize(arg2);
100076     } catch (std::out_of_range& e) {
100077       {
100078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100079       };
100080     } catch (std::exception& e) {
100081       {
100082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100083       };
100084     } catch (...) {
100085       {
100086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100087       };
100088     }
100089   }
100090 }
100091
100092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100093   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100094   Dali::Window arg2 ;
100095   Dali::Window *argp2 ;
100096
100097   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100098   argp2 = (Dali::Window *)jarg2;
100099   if (!argp2) {
100100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100101     return ;
100102   }
100103   arg2 = *argp2;
100104   {
100105     try {
100106       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100107     } catch (std::out_of_range& e) {
100108       {
100109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100110       };
100111     } catch (std::exception& e) {
100112       {
100113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100114       };
100115     } catch (...) {
100116       {
100117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100118       };
100119     }
100120   }
100121 }
100122
100123
100124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100125   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100126   std::string *arg2 = 0 ;
100127   int arg3 ;
100128
100129   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100130   if (!jarg2) {
100131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100132     return ;
100133   }
100134   std::string arg2_str(jarg2);
100135   arg2 = &arg2_str;
100136   arg3 = (int)jarg3;
100137   {
100138     try {
100139       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100140     } catch (std::out_of_range& e) {
100141       {
100142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100143       };
100144     } catch (std::exception& e) {
100145       {
100146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100147       };
100148     } catch (...) {
100149       {
100150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100151       };
100152     }
100153   }
100154 }
100155
100156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100157   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100158   std::string *arg2 = 0 ;
100159   int arg3 ;
100160
100161   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100162   if (!jarg2) {
100163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100164     return ;
100165   }
100166   std::string arg2_str(jarg2);
100167   arg2 = &arg2_str;
100168   arg3 = (int)jarg3;
100169   {
100170     try {
100171       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100172     } catch (std::out_of_range& e) {
100173       {
100174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100175       };
100176     } catch (std::exception& e) {
100177       {
100178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100179       };
100180     } catch (...) {
100181       {
100182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100183       };
100184     }
100185   }
100186 }
100187
100188
100189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100190   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100191   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100192   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100193
100194   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100195   arg2 = (Dali::SlotObserver *)jarg2;
100196   arg3 = (Dali::CallbackBase *)jarg3;
100197   {
100198     try {
100199       (arg1)->SignalConnected(arg2,arg3);
100200     } catch (std::out_of_range& e) {
100201       {
100202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100203       };
100204     } catch (std::exception& e) {
100205       {
100206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100207       };
100208     } catch (...) {
100209       {
100210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100211       };
100212     }
100213   }
100214 }
100215
100216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100217   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100218   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100219   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100220
100221   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100222   arg2 = (Dali::SlotObserver *)jarg2;
100223   arg3 = (Dali::CallbackBase *)jarg3;
100224   {
100225     try {
100226       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100227     } catch (std::out_of_range& e) {
100228       {
100229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100230       };
100231     } catch (std::exception& e) {
100232       {
100233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100234       };
100235     } catch (...) {
100236       {
100237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100238       };
100239     }
100240   }
100241 }
100242
100243
100244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100245   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100246   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100247   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100248
100249   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100250   arg2 = (Dali::SlotObserver *)jarg2;
100251   arg3 = (Dali::CallbackBase *)jarg3;
100252   {
100253     try {
100254       (arg1)->SignalDisconnected(arg2,arg3);
100255     } catch (std::out_of_range& e) {
100256       {
100257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100258       };
100259     } catch (std::exception& e) {
100260       {
100261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100262       };
100263     } catch (...) {
100264       {
100265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100266       };
100267     }
100268   }
100269 }
100270
100271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100272   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100273   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100274   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100275
100276   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100277   arg2 = (Dali::SlotObserver *)jarg2;
100278   arg3 = (Dali::CallbackBase *)jarg3;
100279   {
100280     try {
100281       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
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_SetContentInfo(void * jarg1, char * jarg2) {
100299   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100300   std::string *arg2 = 0 ;
100301
100302   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100303   if (!jarg2) {
100304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100305     return ;
100306   }
100307   std::string arg2_str(jarg2);
100308   arg2 = &arg2_str;
100309   {
100310     try {
100311       (arg1)->SetContentInfo((std::string const &)*arg2);
100312     } catch (std::out_of_range& e) {
100313       {
100314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100315       };
100316     } catch (std::exception& e) {
100317       {
100318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100319       };
100320     } catch (...) {
100321       {
100322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100323       };
100324     }
100325   }
100326 }
100327
100328
100329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100330   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100331   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100332
100333   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100334   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100335   {
100336     try {
100337       (arg1)->SetImpl(arg2);
100338     } catch (std::out_of_range& e) {
100339       {
100340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100341       };
100342     } catch (std::exception& e) {
100343       {
100344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100345       };
100346     } catch (...) {
100347       {
100348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100349       };
100350     }
100351   }
100352 }
100353
100354 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) {
100355
100356   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100357   if (director) {
100358     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100359   }
100360 }
100361
100362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100363   void * jresult ;
100364   Dali::Widget *arg1 = 0 ;
100365   SwigDirector_WidgetImpl *result = 0 ;
100366
100367   arg1 = (Dali::Widget *)jarg1;
100368   if (!arg1) {
100369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100370     return 0;
100371   }
100372   {
100373     try {
100374       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100375     } catch (std::out_of_range& e) {
100376       {
100377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100378       };
100379     } catch (std::exception& e) {
100380       {
100381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100382       };
100383     } catch (...) {
100384       {
100385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100386       };
100387     }
100388   }
100389
100390   jresult = (void *)result;
100391   return jresult;
100392 }
100393
100394
100395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100396   void * jresult ;
100397   int *arg1 = (int *) 0 ;
100398   char ***arg2 ;
100399   std::string *arg3 = 0 ;
100400   Dali::WidgetApplication result;
100401   {
100402     int index = 0;
100403     int length = 0;
100404     char *retPtr;
100405     char *nextPtr;
100406     argWidgetC = jarg1;
100407     argWidgetV = new char*[jarg1 + 1];
100408
100409     retPtr = strtok_r( jarg2, " ", &nextPtr);
100410     if( retPtr )
100411     {
100412       length = strlen(retPtr);
100413     }
100414     argWidgetV[index] = new char[length + 1];
100415     if( retPtr )
100416     {
100417       strncpy(argWidgetV[index], retPtr, length);
100418     }
100419     argWidgetV[index][length] = '\0';
100420     index++;
100421
100422     while (index < jarg1)
100423     {
100424       length = 0;
100425       retPtr = strtok_r(NULL, " ", &nextPtr);
100426       if( retPtr )
100427       {
100428         length = strlen(retPtr);
100429       }
100430       argWidgetV[index] = new char[length + 1];
100431       if( retPtr )
100432       {
100433         strncpy(argWidgetV[index], retPtr, length);
100434       }
100435       argWidgetV[index][length] = '\0';
100436       index++;
100437     }
100438
100439     argWidgetV[jarg1] = NULL;
100440     argWidgetC = jarg1;
100441
100442     arg1 = &argWidgetC;
100443     arg2 = &argWidgetV;
100444   }
100445
100446   if (!jarg3) {
100447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100448     return 0;
100449   }
100450   std::string arg3_str(jarg3);
100451   arg3 = &arg3_str;
100452   {
100453     try {
100454       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100455     } catch (std::out_of_range& e) {
100456       {
100457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100458       };
100459     } catch (std::exception& e) {
100460       {
100461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100462       };
100463     } catch (...) {
100464       {
100465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100466       };
100467     }
100468   }
100469   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100470
100471   return jresult;
100472 }
100473
100474
100475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100476   void * jresult ;
100477   Dali::WidgetApplication *result = 0 ;
100478
100479   {
100480     try {
100481       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100482     } catch (std::out_of_range& e) {
100483       {
100484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100485       };
100486     } catch (std::exception& e) {
100487       {
100488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (...) {
100491       {
100492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100493       };
100494     }
100495   }
100496   jresult = (void *)result;
100497   return jresult;
100498 }
100499
100500
100501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100502   void * jresult ;
100503   Dali::WidgetApplication *arg1 = 0 ;
100504   Dali::WidgetApplication *result = 0 ;
100505
100506   arg1 = (Dali::WidgetApplication *)jarg1;
100507   if (!arg1) {
100508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100509     return 0;
100510   }
100511   {
100512     try {
100513       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100514     } catch (std::out_of_range& e) {
100515       {
100516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100517       };
100518     } catch (std::exception& e) {
100519       {
100520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100521       };
100522     } catch (...) {
100523       {
100524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100525       };
100526     }
100527   }
100528   jresult = (void *)result;
100529   return jresult;
100530 }
100531
100532
100533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100534   void * jresult ;
100535   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100536   Dali::WidgetApplication *arg2 = 0 ;
100537   Dali::WidgetApplication *result = 0 ;
100538
100539   arg1 = (Dali::WidgetApplication *)jarg1;
100540   arg2 = (Dali::WidgetApplication *)jarg2;
100541   if (!arg2) {
100542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100543     return 0;
100544   }
100545   {
100546     try {
100547       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100548     } catch (std::out_of_range& e) {
100549       {
100550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100551       };
100552     } catch (std::exception& e) {
100553       {
100554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100555       };
100556     } catch (...) {
100557       {
100558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100559       };
100560     }
100561   }
100562   jresult = (void *)result;
100563   return jresult;
100564 }
100565
100566
100567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100568   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100569
100570   arg1 = (Dali::WidgetApplication *)jarg1;
100571   {
100572     try {
100573       delete arg1;
100574       if( argWidgetV )
100575       {
100576         // free string data
100577         for( int i=0; i < argWidgetC+1; i++)
100578         {
100579           delete [] argWidgetV[i];
100580         }
100581         delete [] argWidgetV;
100582       }
100583     } catch (std::out_of_range& e) {
100584       {
100585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100586       };
100587     } catch (std::exception& e) {
100588       {
100589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100590       };
100591     } catch (...) {
100592       {
100593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100594       };
100595     }
100596   }
100597 }
100598
100599
100600 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100601 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100602
100603 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100604 {
100605   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100606   return *widget;
100607 }
100608
100609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100610   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100611   std::string *arg2 = 0 ;
100612
100613   arg1 = (Dali::WidgetApplication *)jarg1;
100614   if (!jarg2) {
100615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100616     return ;
100617   }
100618   std::string arg2_str(*jarg2);
100619   arg2 = &arg2_str;
100620
100621   if(!_CSharpCreateWidgetFunction)
100622   {
100623     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100624   }
100625
100626   {
100627     try {
100628       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100629     } catch (std::out_of_range& e) {
100630       {
100631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100632       };
100633     } catch (std::exception& e) {
100634       {
100635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100636       };
100637     } catch (...) {
100638       {
100639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100640       };
100641     }
100642   }
100643
100644   //Typemap argout in c++ file.
100645   //This will convert c++ string to c# string
100646   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100647 }
100648
100649
100650 //for PixelBuffer and ImageLoading
100651
100652 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100653     return (Dali::BaseHandle *)jarg1;
100654 }
100655
100656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100657   void * jresult ;
100658   unsigned int arg1 ;
100659   unsigned int arg2 ;
100660   Dali::Pixel::Format arg3 ;
100661   Dali::Devel::PixelBuffer result;
100662
100663   arg1 = (unsigned int)jarg1;
100664   arg2 = (unsigned int)jarg2;
100665   arg3 = (Dali::Pixel::Format)jarg3;
100666   {
100667     try {
100668       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100669     } catch (std::out_of_range& e) {
100670       {
100671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100672       };
100673     } catch (std::exception& e) {
100674       {
100675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100676       };
100677     } catch (...) {
100678       {
100679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100680       };
100681     }
100682   }
100683   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100684   return jresult;
100685 }
100686
100687
100688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100689   void * jresult ;
100690   Dali::Devel::PixelBuffer *result = 0 ;
100691
100692   {
100693     try {
100694       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100695     } catch (std::out_of_range& e) {
100696       {
100697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100698       };
100699     } catch (std::exception& e) {
100700       {
100701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100702       };
100703     } catch (...) {
100704       {
100705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100706       };
100707     }
100708   }
100709   jresult = (void *)result;
100710   return jresult;
100711 }
100712
100713
100714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100715   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100716
100717   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100718   {
100719     try {
100720       delete arg1;
100721     } catch (std::out_of_range& e) {
100722       {
100723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100724       };
100725     } catch (std::exception& e) {
100726       {
100727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100728       };
100729     } catch (...) {
100730       {
100731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100732       };
100733     }
100734   }
100735 }
100736
100737
100738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
100739   void * jresult ;
100740   Dali::Devel::PixelBuffer *arg1 = 0 ;
100741   Dali::Devel::PixelBuffer *result = 0 ;
100742
100743   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100744   if (!arg1) {
100745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100746     return 0;
100747   }
100748   {
100749     try {
100750       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
100751     } catch (std::out_of_range& e) {
100752       {
100753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100754       };
100755     } catch (std::exception& e) {
100756       {
100757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100758       };
100759     } catch (...) {
100760       {
100761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100762       };
100763     }
100764   }
100765   jresult = (void *)result;
100766   return jresult;
100767 }
100768
100769
100770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
100771   void * jresult ;
100772   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100773   Dali::Devel::PixelBuffer *arg2 = 0 ;
100774   Dali::Devel::PixelBuffer *result = 0 ;
100775
100776   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100777   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
100778   if (!arg2) {
100779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100780     return 0;
100781   }
100782   {
100783     try {
100784       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
100785     } catch (std::out_of_range& e) {
100786       {
100787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100788       };
100789     } catch (std::exception& e) {
100790       {
100791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100792       };
100793     } catch (...) {
100794       {
100795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100796       };
100797     }
100798   }
100799   jresult = (void *)result;
100800   return jresult;
100801 }
100802
100803
100804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
100805   void * jresult ;
100806   Dali::Devel::PixelBuffer *arg1 = 0 ;
100807   Dali::PixelData result;
100808
100809   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100810   if (!arg1) {
100811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
100812     return 0;
100813   }
100814   {
100815     try {
100816       result = Dali::Devel::PixelBuffer::Convert(*arg1);
100817     } catch (std::out_of_range& e) {
100818       {
100819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100820       };
100821     } catch (std::exception& e) {
100822       {
100823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100824       };
100825     } catch (...) {
100826       {
100827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100828       };
100829     }
100830   }
100831   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100832   return jresult;
100833 }
100834
100835
100836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
100837   void * jresult ;
100838   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100839   Dali::PixelData result;
100840
100841   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100842   {
100843     try {
100844       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
100845     } catch (std::out_of_range& e) {
100846       {
100847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100848       };
100849     } catch (std::exception& e) {
100850       {
100851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100852       };
100853     } catch (...) {
100854       {
100855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100856       };
100857     }
100858   }
100859   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100860   return jresult;
100861 }
100862
100863
100864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
100865   void * jresult ;
100866   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100867   unsigned char *result = 0 ;
100868
100869   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100870   {
100871     try {
100872       result = (unsigned char *)(arg1)->GetBuffer();
100873     } catch (std::out_of_range& e) {
100874       {
100875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100876       };
100877     } catch (std::exception& e) {
100878       {
100879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100880       };
100881     } catch (...) {
100882       {
100883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100884       };
100885     }
100886   }
100887   jresult = (void *)result;
100888   return jresult;
100889 }
100890
100891
100892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
100893   unsigned int jresult ;
100894   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100895   unsigned int result;
100896
100897   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100898   {
100899     try {
100900       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
100901     } catch (std::out_of_range& e) {
100902       {
100903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100904       };
100905     } catch (std::exception& e) {
100906       {
100907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100908       };
100909     } catch (...) {
100910       {
100911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100912       };
100913     }
100914   }
100915   jresult = result;
100916   return jresult;
100917 }
100918
100919
100920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
100921   unsigned int jresult ;
100922   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100923   unsigned int result;
100924
100925   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100926   {
100927     try {
100928       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
100929     } catch (std::out_of_range& e) {
100930       {
100931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100932       };
100933     } catch (std::exception& e) {
100934       {
100935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100936       };
100937     } catch (...) {
100938       {
100939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100940       };
100941     }
100942   }
100943   jresult = result;
100944   return jresult;
100945 }
100946
100947
100948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
100949   int jresult ;
100950   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100951   Dali::Pixel::Format result;
100952
100953   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100954   {
100955     try {
100956       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
100957     } catch (std::out_of_range& e) {
100958       {
100959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100960       };
100961     } catch (std::exception& e) {
100962       {
100963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100964       };
100965     } catch (...) {
100966       {
100967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100968       };
100969     }
100970   }
100971   jresult = (int)result;
100972   return jresult;
100973 }
100974
100975
100976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
100977   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100978   Dali::Devel::PixelBuffer arg2 ;
100979   float arg3 ;
100980   bool arg4 ;
100981   Dali::Devel::PixelBuffer *argp2 ;
100982
100983   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100984   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
100985   if (!argp2) {
100986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
100987     return ;
100988   }
100989   arg2 = *argp2;
100990   arg3 = (float)jarg3;
100991   arg4 = jarg4 ? true : false;
100992   {
100993     try {
100994       (arg1)->ApplyMask(arg2,arg3,arg4);
100995     } catch (std::out_of_range& e) {
100996       {
100997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100998       };
100999     } catch (std::exception& e) {
101000       {
101001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101002       };
101003     } catch (...) {
101004       {
101005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101006       };
101007     }
101008   }
101009 }
101010
101011
101012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101013   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101014   Dali::Devel::PixelBuffer arg2 ;
101015   float arg3 ;
101016   Dali::Devel::PixelBuffer *argp2 ;
101017
101018   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101019   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101020   if (!argp2) {
101021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101022     return ;
101023   }
101024   arg2 = *argp2;
101025   arg3 = (float)jarg3;
101026   {
101027     try {
101028       (arg1)->ApplyMask(arg2,arg3);
101029     } catch (std::out_of_range& e) {
101030       {
101031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101032       };
101033     } catch (std::exception& e) {
101034       {
101035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101036       };
101037     } catch (...) {
101038       {
101039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101040       };
101041     }
101042   }
101043 }
101044
101045
101046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101047   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101048   Dali::Devel::PixelBuffer arg2 ;
101049   Dali::Devel::PixelBuffer *argp2 ;
101050
101051   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101052   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101053   if (!argp2) {
101054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101055     return ;
101056   }
101057   arg2 = *argp2;
101058   {
101059     try {
101060       (arg1)->ApplyMask(arg2);
101061     } catch (std::out_of_range& e) {
101062       {
101063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101064       };
101065     } catch (std::exception& e) {
101066       {
101067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101068       };
101069     } catch (...) {
101070       {
101071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101072       };
101073     }
101074   }
101075 }
101076
101077
101078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101079   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101080   float arg2 ;
101081
101082   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101083   arg2 = (float)jarg2;
101084   {
101085     try {
101086       (arg1)->ApplyGaussianBlur(arg2);
101087     } catch (std::out_of_range& e) {
101088       {
101089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101090       };
101091     } catch (std::exception& e) {
101092       {
101093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101094       };
101095     } catch (...) {
101096       {
101097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101098       };
101099     }
101100   }
101101 }
101102
101103
101104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101105   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101106   uint16_t arg2 ;
101107   uint16_t arg3 ;
101108   uint16_t arg4 ;
101109   uint16_t arg5 ;
101110
101111   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101112   arg2 = (uint16_t)jarg2;
101113   arg3 = (uint16_t)jarg3;
101114   arg4 = (uint16_t)jarg4;
101115   arg5 = (uint16_t)jarg5;
101116   {
101117     try {
101118       (arg1)->Crop(arg2,arg3,arg4,arg5);
101119     } catch (std::out_of_range& e) {
101120       {
101121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101122       };
101123     } catch (std::exception& e) {
101124       {
101125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101126       };
101127     } catch (...) {
101128       {
101129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101130       };
101131     }
101132   }
101133 }
101134
101135
101136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101137   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101138   uint16_t arg2 ;
101139   uint16_t arg3 ;
101140
101141   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101142   arg2 = (uint16_t)jarg2;
101143   arg3 = (uint16_t)jarg3;
101144   {
101145     try {
101146       (arg1)->Resize(arg2,arg3);
101147     } catch (std::out_of_range& e) {
101148       {
101149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101150       };
101151     } catch (std::exception& e) {
101152       {
101153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101154       };
101155     } catch (...) {
101156       {
101157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101158       };
101159     }
101160   }
101161 }
101162
101163 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
101164   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101165   Dali::Degree * arg2 ;
101166
101167   bool result = false;
101168
101169   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101170   arg2 = (Dali::Degree *)jarg2;
101171   {
101172     try {
101173       result = (arg1)->Rotate(*arg2);
101174     } catch (std::out_of_range& e) {
101175       {
101176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
101177       };
101178     } catch (std::exception& e) {
101179       {
101180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
101181       };
101182     } catch (...) {
101183       {
101184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
101185       };
101186     }
101187   }
101188   return result;
101189 }
101190
101191
101192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101193   void * jresult ;
101194   std::string *arg1 = 0 ;
101195   Dali::ImageDimensions arg2 ;
101196   Dali::FittingMode::Type arg3 ;
101197   Dali::SamplingMode::Type arg4 ;
101198   bool arg5 ;
101199   Dali::ImageDimensions *argp2 ;
101200   Dali::Devel::PixelBuffer result;
101201
101202   if (!jarg1) {
101203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101204     return 0;
101205   }
101206   std::string arg1_str(jarg1);
101207   arg1 = &arg1_str;
101208   argp2 = (Dali::ImageDimensions *)jarg2;
101209   if (!argp2) {
101210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101211     return 0;
101212   }
101213   arg2 = *argp2;
101214   arg3 = (Dali::FittingMode::Type)jarg3;
101215   arg4 = (Dali::SamplingMode::Type)jarg4;
101216   arg5 = jarg5 ? true : false;
101217   {
101218     try {
101219       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101220     } catch (std::out_of_range& e) {
101221       {
101222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101223       };
101224     } catch (std::exception& e) {
101225       {
101226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101227       };
101228     } catch (...) {
101229       {
101230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101231       };
101232     }
101233   }
101234   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101235
101236   return jresult;
101237 }
101238
101239
101240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101241   void * jresult ;
101242   std::string *arg1 = 0 ;
101243   Dali::ImageDimensions arg2 ;
101244   Dali::FittingMode::Type arg3 ;
101245   Dali::SamplingMode::Type arg4 ;
101246   Dali::ImageDimensions *argp2 ;
101247   Dali::Devel::PixelBuffer result;
101248
101249   if (!jarg1) {
101250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101251     return 0;
101252   }
101253   std::string arg1_str(jarg1);
101254   arg1 = &arg1_str;
101255   argp2 = (Dali::ImageDimensions *)jarg2;
101256   if (!argp2) {
101257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101258     return 0;
101259   }
101260   arg2 = *argp2;
101261   arg3 = (Dali::FittingMode::Type)jarg3;
101262   arg4 = (Dali::SamplingMode::Type)jarg4;
101263   {
101264     try {
101265       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
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 = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101281
101282   return jresult;
101283 }
101284
101285
101286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101287   void * jresult ;
101288   std::string *arg1 = 0 ;
101289   Dali::ImageDimensions arg2 ;
101290   Dali::FittingMode::Type arg3 ;
101291   Dali::ImageDimensions *argp2 ;
101292   Dali::Devel::PixelBuffer result;
101293
101294   if (!jarg1) {
101295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101296     return 0;
101297   }
101298   std::string arg1_str(jarg1);
101299   arg1 = &arg1_str;
101300   argp2 = (Dali::ImageDimensions *)jarg2;
101301   if (!argp2) {
101302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101303     return 0;
101304   }
101305   arg2 = *argp2;
101306   arg3 = (Dali::FittingMode::Type)jarg3;
101307   {
101308     try {
101309       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101310     } catch (std::out_of_range& e) {
101311       {
101312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101313       };
101314     } catch (std::exception& e) {
101315       {
101316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101317       };
101318     } catch (...) {
101319       {
101320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101321       };
101322     }
101323   }
101324   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101325
101326   return jresult;
101327 }
101328
101329
101330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101331   void * jresult ;
101332   std::string *arg1 = 0 ;
101333   Dali::ImageDimensions arg2 ;
101334   Dali::ImageDimensions *argp2 ;
101335   Dali::Devel::PixelBuffer result;
101336
101337   if (!jarg1) {
101338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101339     return 0;
101340   }
101341   std::string arg1_str(jarg1);
101342   arg1 = &arg1_str;
101343   argp2 = (Dali::ImageDimensions *)jarg2;
101344   if (!argp2) {
101345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101346     return 0;
101347   }
101348   arg2 = *argp2;
101349   {
101350     try {
101351       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101352     } catch (std::out_of_range& e) {
101353       {
101354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101355       };
101356     } catch (std::exception& e) {
101357       {
101358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101359       };
101360     } catch (...) {
101361       {
101362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101363       };
101364     }
101365   }
101366   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101367
101368   return jresult;
101369 }
101370
101371
101372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101373   void * jresult ;
101374   std::string *arg1 = 0 ;
101375   Dali::Devel::PixelBuffer result;
101376
101377   if (!jarg1) {
101378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101379     return 0;
101380   }
101381   std::string arg1_str(jarg1);
101382   arg1 = &arg1_str;
101383   {
101384     try {
101385       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101386     } catch (std::out_of_range& e) {
101387       {
101388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101389       };
101390     } catch (std::exception& e) {
101391       {
101392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101393       };
101394     } catch (...) {
101395       {
101396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101397       };
101398     }
101399   }
101400   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101401
101402   return jresult;
101403 }
101404
101405
101406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101407   void * jresult ;
101408   std::string *arg1 = 0 ;
101409   Dali::ImageDimensions arg2 ;
101410   Dali::FittingMode::Type arg3 ;
101411   Dali::SamplingMode::Type arg4 ;
101412   bool arg5 ;
101413   Dali::ImageDimensions *argp2 ;
101414   Dali::ImageDimensions result;
101415
101416   if (!jarg1) {
101417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101418     return 0;
101419   }
101420   std::string arg1_str(jarg1);
101421   arg1 = &arg1_str;
101422   argp2 = (Dali::ImageDimensions *)jarg2;
101423   if (!argp2) {
101424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101425     return 0;
101426   }
101427   arg2 = *argp2;
101428   arg3 = (Dali::FittingMode::Type)jarg3;
101429   arg4 = (Dali::SamplingMode::Type)jarg4;
101430   arg5 = jarg5 ? true : false;
101431   {
101432     try {
101433       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101434     } catch (std::out_of_range& e) {
101435       {
101436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101437       };
101438     } catch (std::exception& e) {
101439       {
101440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101441       };
101442     } catch (...) {
101443       {
101444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101445       };
101446     }
101447   }
101448   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101449
101450   return jresult;
101451 }
101452
101453
101454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101455   void * jresult ;
101456   std::string *arg1 = 0 ;
101457   Dali::ImageDimensions arg2 ;
101458   Dali::FittingMode::Type arg3 ;
101459   Dali::SamplingMode::Type arg4 ;
101460   Dali::ImageDimensions *argp2 ;
101461   Dali::ImageDimensions result;
101462
101463   if (!jarg1) {
101464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101465     return 0;
101466   }
101467   std::string arg1_str(jarg1);
101468   arg1 = &arg1_str;
101469   argp2 = (Dali::ImageDimensions *)jarg2;
101470   if (!argp2) {
101471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101472     return 0;
101473   }
101474   arg2 = *argp2;
101475   arg3 = (Dali::FittingMode::Type)jarg3;
101476   arg4 = (Dali::SamplingMode::Type)jarg4;
101477   {
101478     try {
101479       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101480     } catch (std::out_of_range& e) {
101481       {
101482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101483       };
101484     } catch (std::exception& e) {
101485       {
101486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101487       };
101488     } catch (...) {
101489       {
101490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101491       };
101492     }
101493   }
101494   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101495
101496   return jresult;
101497 }
101498
101499
101500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101501   void * jresult ;
101502   std::string *arg1 = 0 ;
101503   Dali::ImageDimensions arg2 ;
101504   Dali::FittingMode::Type arg3 ;
101505   Dali::ImageDimensions *argp2 ;
101506   Dali::ImageDimensions result;
101507
101508   if (!jarg1) {
101509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101510     return 0;
101511   }
101512   std::string arg1_str(jarg1);
101513   arg1 = &arg1_str;
101514   argp2 = (Dali::ImageDimensions *)jarg2;
101515   if (!argp2) {
101516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101517     return 0;
101518   }
101519   arg2 = *argp2;
101520   arg3 = (Dali::FittingMode::Type)jarg3;
101521   {
101522     try {
101523       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101524     } catch (std::out_of_range& e) {
101525       {
101526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101527       };
101528     } catch (std::exception& e) {
101529       {
101530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101531       };
101532     } catch (...) {
101533       {
101534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101535       };
101536     }
101537   }
101538   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101539
101540   return jresult;
101541 }
101542
101543
101544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101545   void * jresult ;
101546   std::string *arg1 = 0 ;
101547   Dali::ImageDimensions arg2 ;
101548   Dali::ImageDimensions *argp2 ;
101549   Dali::ImageDimensions result;
101550
101551   if (!jarg1) {
101552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101553     return 0;
101554   }
101555   std::string arg1_str(jarg1);
101556   arg1 = &arg1_str;
101557   argp2 = (Dali::ImageDimensions *)jarg2;
101558   if (!argp2) {
101559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101560     return 0;
101561   }
101562   arg2 = *argp2;
101563   {
101564     try {
101565       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101566     } catch (std::out_of_range& e) {
101567       {
101568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101569       };
101570     } catch (std::exception& e) {
101571       {
101572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101573       };
101574     } catch (...) {
101575       {
101576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101577       };
101578     }
101579   }
101580   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101581
101582   return jresult;
101583 }
101584
101585
101586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101587   void * jresult ;
101588   std::string *arg1 = 0 ;
101589   Dali::ImageDimensions result;
101590
101591   if (!jarg1) {
101592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101593     return 0;
101594   }
101595   std::string arg1_str(jarg1);
101596   arg1 = &arg1_str;
101597   {
101598     try {
101599       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101600     } catch (std::out_of_range& e) {
101601       {
101602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101603       };
101604     } catch (std::exception& e) {
101605       {
101606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101607       };
101608     } catch (...) {
101609       {
101610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101611       };
101612     }
101613   }
101614   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101615
101616   return jresult;
101617 }
101618
101619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101620   void * jresult ;
101621   std::string *arg1 = 0 ;
101622   Dali::ImageDimensions result;
101623
101624   if (!jarg1) {
101625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101626     return 0;
101627   }
101628   std::string arg1_str(jarg1);
101629   arg1 = &arg1_str;
101630   {
101631     try {
101632       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
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::ImageDimensions((const Dali::ImageDimensions &)result);
101648
101649   return jresult;
101650 }
101651
101652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101653   void * jresult ;
101654   std::string *arg1 = 0 ;
101655   Dali::ImageDimensions arg2 ;
101656   Dali::FittingMode::Type arg3 ;
101657   Dali::SamplingMode::Type arg4 ;
101658   bool arg5 ;
101659   Dali::ImageDimensions *argp2 ;
101660   Dali::Devel::PixelBuffer result;
101661
101662   if (!jarg1) {
101663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101664     return 0;
101665   }
101666   std::string arg1_str(jarg1);
101667   arg1 = &arg1_str;
101668   argp2 = (Dali::ImageDimensions *)jarg2;
101669   if (!argp2) {
101670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101671     return 0;
101672   }
101673   arg2 = *argp2;
101674   arg3 = (Dali::FittingMode::Type)jarg3;
101675   arg4 = (Dali::SamplingMode::Type)jarg4;
101676   arg5 = jarg5 ? true : false;
101677   {
101678     try {
101679       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101680     } catch (std::out_of_range& e) {
101681       {
101682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101683       };
101684     } catch (std::exception& e) {
101685       {
101686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101687       };
101688     } catch (...) {
101689       {
101690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101691       };
101692     }
101693   }
101694   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101695
101696   return jresult;
101697 }
101698
101699
101700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101701   void * jresult ;
101702   std::string *arg1 = 0 ;
101703   Dali::ImageDimensions arg2 ;
101704   Dali::FittingMode::Type arg3 ;
101705   Dali::SamplingMode::Type arg4 ;
101706   Dali::ImageDimensions *argp2 ;
101707   Dali::Devel::PixelBuffer result;
101708
101709   if (!jarg1) {
101710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101711     return 0;
101712   }
101713   std::string arg1_str(jarg1);
101714   arg1 = &arg1_str;
101715   argp2 = (Dali::ImageDimensions *)jarg2;
101716   if (!argp2) {
101717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101718     return 0;
101719   }
101720   arg2 = *argp2;
101721   arg3 = (Dali::FittingMode::Type)jarg3;
101722   arg4 = (Dali::SamplingMode::Type)jarg4;
101723   {
101724     try {
101725       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101726     } catch (std::out_of_range& e) {
101727       {
101728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101729       };
101730     } catch (std::exception& e) {
101731       {
101732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101733       };
101734     } catch (...) {
101735       {
101736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101737       };
101738     }
101739   }
101740   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101741
101742   return jresult;
101743 }
101744
101745
101746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101747   void * jresult ;
101748   std::string *arg1 = 0 ;
101749   Dali::ImageDimensions arg2 ;
101750   Dali::FittingMode::Type arg3 ;
101751   Dali::ImageDimensions *argp2 ;
101752   Dali::Devel::PixelBuffer result;
101753
101754   if (!jarg1) {
101755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101756     return 0;
101757   }
101758   std::string arg1_str(jarg1);
101759   arg1 = &arg1_str;
101760   argp2 = (Dali::ImageDimensions *)jarg2;
101761   if (!argp2) {
101762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101763     return 0;
101764   }
101765   arg2 = *argp2;
101766   arg3 = (Dali::FittingMode::Type)jarg3;
101767   {
101768     try {
101769       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
101770     } catch (std::out_of_range& e) {
101771       {
101772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101773       };
101774     } catch (std::exception& e) {
101775       {
101776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101777       };
101778     } catch (...) {
101779       {
101780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101781       };
101782     }
101783   }
101784   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101785
101786   return jresult;
101787 }
101788
101789
101790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
101791   void * jresult ;
101792   std::string *arg1 = 0 ;
101793   Dali::ImageDimensions arg2 ;
101794   Dali::ImageDimensions *argp2 ;
101795   Dali::Devel::PixelBuffer result;
101796
101797   if (!jarg1) {
101798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101799     return 0;
101800   }
101801   std::string arg1_str(jarg1);
101802   arg1 = &arg1_str;
101803   argp2 = (Dali::ImageDimensions *)jarg2;
101804   if (!argp2) {
101805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101806     return 0;
101807   }
101808   arg2 = *argp2;
101809   {
101810     try {
101811       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
101812     } catch (std::out_of_range& e) {
101813       {
101814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101815       };
101816     } catch (std::exception& e) {
101817       {
101818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101819       };
101820     } catch (...) {
101821       {
101822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101823       };
101824     }
101825   }
101826   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101827
101828   return jresult;
101829 }
101830
101831
101832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
101833   void * jresult ;
101834   std::string *arg1 = 0 ;
101835   Dali::Devel::PixelBuffer result;
101836
101837   if (!jarg1) {
101838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101839     return 0;
101840   }
101841   std::string arg1_str(jarg1);
101842   arg1 = &arg1_str;
101843   {
101844     try {
101845       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
101846     } catch (std::out_of_range& e) {
101847       {
101848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101849       };
101850     } catch (std::exception& e) {
101851       {
101852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101853       };
101854     } catch (...) {
101855       {
101856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101857       };
101858     }
101859   }
101860   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101861
101862   return jresult;
101863 }
101864
101865
101866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
101867   void * jresult ;
101868   Dali::Toolkit::WebView result;
101869
101870   {
101871     try {
101872       result = Dali::Toolkit::WebView::New();
101873     } catch (std::out_of_range& e) {
101874       {
101875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101876       };
101877     } catch (std::exception& e) {
101878       {
101879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101880       };
101881     } catch (Dali::DaliException e) {
101882       {
101883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101884       };
101885     } catch (...) {
101886       {
101887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101888       };
101889     }
101890   }
101891   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101892   return jresult;
101893 }
101894
101895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
101896   void * jresult ;
101897   Dali::Toolkit::WebView result;
101898
101899   std::string *arg1;
101900   std::string *arg2;
101901
101902   if (!jarg1) {
101903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
101904     return 0;
101905   }
101906   if (!jarg2) {
101907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
101908     return 0;
101909   }
101910
101911   std::string jarg1_str = std::string(jarg1);
101912   std::string jarg2_str = std::string(jarg2);
101913
101914   arg1 = &jarg1_str;
101915   arg2 = &jarg2_str;
101916
101917   {
101918     try {
101919       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
101920     } catch (std::out_of_range& e) {
101921       {
101922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101923       };
101924     } catch (std::exception& e) {
101925       {
101926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101927       };
101928     } catch (Dali::DaliException e) {
101929       {
101930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101931       };
101932     } catch (...) {
101933       {
101934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101935       };
101936     }
101937   }
101938   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101939   return jresult;
101940 }
101941
101942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
101943   void * jresult ;
101944   Dali::Toolkit::WebView *arg1 = 0 ;
101945   Dali::Toolkit::WebView *result = 0 ;
101946
101947   arg1 = (Dali::Toolkit::WebView *)jarg1;
101948   if (!arg1) {
101949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
101950     return 0;
101951   }
101952   {
101953     try {
101954       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
101955     } catch (std::out_of_range& e) {
101956       {
101957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101958       };
101959     } catch (std::exception& e) {
101960       {
101961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101962       };
101963     } catch (Dali::DaliException e) {
101964       {
101965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101966       };
101967     } catch (...) {
101968       {
101969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101970       };
101971     }
101972   }
101973   jresult = (void *)result;
101974   return jresult;
101975 }
101976
101977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
101978   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101979   arg1 = (Dali::Toolkit::WebView *)jarg1;
101980   {
101981     try {
101982       delete arg1;
101983     } catch (std::out_of_range& e) {
101984       {
101985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101986       };
101987     } catch (std::exception& e) {
101988       {
101989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101990       };
101991     } catch (Dali::DaliException e) {
101992       {
101993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101994       };
101995     } catch (...) {
101996       {
101997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101998       };
101999     }
102000   }
102001 }
102002
102003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102004   void * jresult ;
102005   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102006   Dali::Toolkit::WebView *arg2 = 0 ;
102007   Dali::Toolkit::WebView *result = 0 ;
102008
102009   arg1 = (Dali::Toolkit::WebView *)jarg1;
102010   arg2 = (Dali::Toolkit::WebView *)jarg2;
102011   if (!arg2) {
102012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102013     return 0;
102014   }
102015   {
102016     try {
102017       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102018     } catch (std::out_of_range& e) {
102019       {
102020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102021       };
102022     } catch (std::exception& e) {
102023       {
102024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102025       };
102026     } catch (Dali::DaliException e) {
102027       {
102028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102029       };
102030     } catch (...) {
102031       {
102032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102033       };
102034     }
102035   }
102036   jresult = (void *)result;
102037   return jresult;
102038 }
102039
102040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102041   void * jresult ;
102042   Dali::BaseHandle arg1 ;
102043   Dali::BaseHandle *argp1 ;
102044   Dali::Toolkit::WebView result;
102045
102046   argp1 = (Dali::BaseHandle *)jarg1;
102047   if (!argp1) {
102048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102049     return 0;
102050   }
102051   arg1 = *argp1;
102052   {
102053     try {
102054       result = Dali::Toolkit::WebView::DownCast(arg1);
102055     } catch (std::out_of_range& e) {
102056       {
102057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102058       };
102059     } catch (std::exception& e) {
102060       {
102061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102062       };
102063     } catch (Dali::DaliException e) {
102064       {
102065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102066       };
102067     } catch (...) {
102068       {
102069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102070       };
102071     }
102072   }
102073   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102074   return jresult;
102075 }
102076
102077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102078   return (int) Dali::Toolkit::WebView::Property::URL;
102079 }
102080
102081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102082   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102083 }
102084
102085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102086   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102087 }
102088
102089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102090   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102091 }
102092
102093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102094   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102095 }
102096
102097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102098   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102099 }
102100
102101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102102   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102103 }
102104
102105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102106   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102107 }
102108
102109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102110   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102111   std::string *arg2;
102112
102113   arg1 = (Dali::Toolkit::WebView *)jarg1;
102114
102115   if (!jarg2) {
102116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102117     return;
102118   }
102119
102120   std::string jarg2str = std::string(jarg2);
102121   arg2 = &jarg2str;
102122   {
102123     try {
102124       (arg1)->LoadUrl((std::string const &)*arg2);
102125     } catch (std::out_of_range& e) {
102126       {
102127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102128       };
102129     } catch (std::exception& e) {
102130       {
102131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102132       };
102133     } catch (Dali::DaliException e) {
102134       {
102135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102136       };
102137     } catch (...) {
102138       {
102139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102140       };
102141     }
102142   }
102143 }
102144
102145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102146   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102147   std::string *arg2;
102148
102149   arg1 = (Dali::Toolkit::WebView *)jarg1;
102150   if (!jarg2) {
102151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102152     return;
102153   }
102154   std::string jarg2str = std::string(jarg2);
102155   arg2 = &jarg2str;
102156   {
102157     try {
102158       (arg1)->LoadHTMLString((std::string const &)*arg2);
102159     } catch (std::out_of_range& e) {
102160       {
102161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102162       };
102163     } catch (std::exception& e) {
102164       {
102165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102166       };
102167     } catch (Dali::DaliException e) {
102168       {
102169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102170       };
102171     } catch (...) {
102172       {
102173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102174       };
102175     }
102176   }
102177 }
102178
102179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102180   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102181
102182   arg1 = (Dali::Toolkit::WebView *)jarg1;
102183   {
102184     try {
102185       (arg1)->Reload();
102186     } catch (std::out_of_range& e) {
102187       {
102188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102189       };
102190     } catch (std::exception& e) {
102191       {
102192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102193       };
102194     } catch (Dali::DaliException e) {
102195       {
102196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102197       };
102198     } catch (...) {
102199       {
102200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102201       };
102202     }
102203   }
102204 }
102205
102206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102207   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102208
102209   arg1 = (Dali::Toolkit::WebView *)jarg1;
102210   {
102211     try {
102212       (arg1)->StopLoading();
102213     } catch (std::out_of_range& e) {
102214       {
102215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102216       };
102217     } catch (std::exception& e) {
102218       {
102219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102220       };
102221     } catch (Dali::DaliException e) {
102222       {
102223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102224       };
102225     } catch (...) {
102226       {
102227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102228       };
102229     }
102230   }
102231 }
102232
102233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102234   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102235
102236   arg1 = (Dali::Toolkit::WebView *)jarg1;
102237   {
102238     try {
102239       (arg1)->Suspend();
102240     } catch (std::out_of_range& e) {
102241       {
102242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102243       };
102244     } catch (std::exception& e) {
102245       {
102246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102247       };
102248     } catch (Dali::DaliException e) {
102249       {
102250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102251       };
102252     } catch (...) {
102253       {
102254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102255       };
102256     }
102257   }
102258 }
102259
102260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102261   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102262
102263   arg1 = (Dali::Toolkit::WebView *)jarg1;
102264   {
102265     try {
102266       (arg1)->Resume();
102267     } catch (std::out_of_range& e) {
102268       {
102269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102270       };
102271     } catch (std::exception& e) {
102272       {
102273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102274       };
102275     } catch (Dali::DaliException e) {
102276       {
102277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102278       };
102279     } catch (...) {
102280       {
102281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102282       };
102283     }
102284   }
102285 }
102286
102287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102288   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102289
102290   arg1 = (Dali::Toolkit::WebView *)jarg1;
102291   {
102292     try {
102293       (arg1)->GoBack();
102294     } catch (std::out_of_range& e) {
102295       {
102296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102297       };
102298     } catch (std::exception& e) {
102299       {
102300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102301       };
102302     } catch (Dali::DaliException e) {
102303       {
102304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102305       };
102306     } catch (...) {
102307       {
102308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102309       };
102310     }
102311   }
102312 }
102313
102314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102315   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102316
102317   arg1 = (Dali::Toolkit::WebView *)jarg1;
102318   {
102319     try {
102320       (arg1)->GoForward();
102321     } catch (std::out_of_range& e) {
102322       {
102323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102324       };
102325     } catch (std::exception& e) {
102326       {
102327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102328       };
102329     } catch (Dali::DaliException e) {
102330       {
102331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102332       };
102333     } catch (...) {
102334       {
102335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102336       };
102337     }
102338   }
102339 }
102340
102341 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102342   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102343   bool ret;
102344
102345   arg1 = (Dali::Toolkit::WebView *)jarg1;
102346   {
102347     try {
102348       ret = (arg1)->CanGoBack();
102349     } catch (std::out_of_range& e) {
102350       {
102351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102352       };
102353     } catch (std::exception& e) {
102354       {
102355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102356       };
102357     } catch (Dali::DaliException e) {
102358       {
102359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102360       };
102361     } catch (...) {
102362       {
102363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102364       };
102365     }
102366   }
102367   return ret;
102368 }
102369
102370 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102371   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102372   bool ret;
102373
102374   arg1 = (Dali::Toolkit::WebView *)jarg1;
102375   {
102376     try {
102377       ret = (arg1)->CanGoForward();
102378     } catch (std::out_of_range& e) {
102379       {
102380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102381       };
102382     } catch (std::exception& e) {
102383       {
102384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102385       };
102386     } catch (Dali::DaliException e) {
102387       {
102388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102389       };
102390     } catch (...) {
102391       {
102392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102393       };
102394     }
102395   }
102396   return ret;
102397 }
102398
102399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102400   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102401   std::string *arg2;
102402
102403   arg1 = (Dali::Toolkit::WebView *)jarg1;
102404   if (!jarg2) {
102405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102406     return;
102407   }
102408   std::string jarg2_str = std::string(jarg2);
102409   arg2 = &jarg2_str;
102410
102411   {
102412     try {
102413       if (jarg3) {
102414         void (*handler)(char*) = (void (*)(char*)) jarg3;
102415         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102416           handler(SWIG_csharp_string_callback(result.c_str()));
102417         });
102418       } else {
102419         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102420       }
102421     } catch (std::out_of_range& e) {
102422       {
102423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102424       };
102425     } catch (std::exception& e) {
102426       {
102427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102428       };
102429     } catch (Dali::DaliException e) {
102430       {
102431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102432       };
102433     } catch (...) {
102434       {
102435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102436       };
102437     }
102438   }
102439 }
102440
102441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102442 {
102443   if (!jarg2) {
102444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102445     return;
102446   }
102447
102448   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102449   std::string exposedObjectName = jarg2;
102450   void (*handler)(char*) = (void (*)(char*)) jarg3;
102451
102452   {
102453     try {
102454       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102455         handler(SWIG_csharp_string_callback(message.c_str()));
102456       });
102457     } catch (std::out_of_range& e) {
102458       {
102459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102460       };
102461     } catch (std::exception& e) {
102462       {
102463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102464       };
102465     } catch (Dali::DaliException e) {
102466       {
102467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102468       };
102469     } catch (...) {
102470       {
102471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102472       };
102473     }
102474   }
102475 }
102476
102477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102478   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102479
102480   arg1 = (Dali::Toolkit::WebView *)jarg1;
102481   {
102482     try {
102483       (arg1)->ClearHistory();
102484     } catch (std::out_of_range& e) {
102485       {
102486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102487       };
102488     } catch (std::exception& e) {
102489       {
102490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102491       };
102492     } catch (Dali::DaliException e) {
102493       {
102494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102495       };
102496     } catch (...) {
102497       {
102498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102499       };
102500     }
102501   }
102502 }
102503
102504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102505   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102506
102507   arg1 = (Dali::Toolkit::WebView *)jarg1;
102508   {
102509     try {
102510       (arg1)->ClearCache();
102511     } catch (std::out_of_range& e) {
102512       {
102513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102514       };
102515     } catch (std::exception& e) {
102516       {
102517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102518       };
102519     } catch (Dali::DaliException e) {
102520       {
102521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102522       };
102523     } catch (...) {
102524       {
102525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102526       };
102527     }
102528   }
102529 }
102530
102531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102532   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102533
102534   arg1 = (Dali::Toolkit::WebView *)jarg1;
102535   {
102536     try {
102537       (arg1)->ClearCookies();
102538     } catch (std::out_of_range& e) {
102539       {
102540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102541       };
102542     } catch (std::exception& e) {
102543       {
102544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102545       };
102546     } catch (Dali::DaliException e) {
102547       {
102548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102549       };
102550     } catch (...) {
102551       {
102552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102553       };
102554     }
102555   }
102556 }
102557
102558 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102559     return (Dali::Toolkit::Control *)jarg1;
102560 }
102561
102562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102563   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102564   SignalConverter::WebViewPageLoadSignal* result = NULL;
102565   {
102566     try {
102567       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102568     } catch (std::out_of_range& e) {
102569       {
102570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102571       };
102572     } catch (std::exception& e) {
102573       {
102574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102575       };
102576     } catch (Dali::DaliException e) {
102577       {
102578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102579       };
102580     } catch (...) {
102581       {
102582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102583       };
102584     }
102585   }
102586   return (void*) result;
102587 }
102588
102589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102590   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102591   SignalConverter::WebViewPageLoadSignal* result = NULL;
102592   {
102593     try {
102594       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102595     } catch (std::out_of_range& e) {
102596       {
102597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102598       };
102599     } catch (std::exception& e) {
102600       {
102601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102602       };
102603     } catch (Dali::DaliException e) {
102604       {
102605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102606       };
102607     } catch (...) {
102608       {
102609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102610       };
102611     }
102612   }
102613   return (void*) result;
102614 }
102615
102616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102617 {
102618   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102619   {
102620     try {
102621       delete object;
102622     } catch (std::out_of_range& e) {
102623       {
102624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102625       };
102626     } catch (std::exception& e) {
102627       {
102628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102629       };
102630     } catch (Dali::DaliException e) {
102631       {
102632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102633       };
102634     } catch (...) {
102635       {
102636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102637       };
102638     }
102639   }
102640 }
102641
102642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102643 {
102644   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102645   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102646   {
102647     try {
102648       proxy->Connect(callback);
102649     } catch (std::out_of_range& e) {
102650       {
102651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102652       };
102653     } catch (std::exception& e) {
102654       {
102655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102656       };
102657     } catch (Dali::DaliException e) {
102658       {
102659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102660       };
102661     } catch (...) {
102662       {
102663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102664       };
102665     }
102666   }
102667 }
102668
102669
102670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102671   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102672   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102673   {
102674     try {
102675       proxy->Disconnect(callback);
102676     } catch (std::out_of_range& e) {
102677       {
102678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102679       };
102680     } catch (std::exception& e) {
102681       {
102682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102683       };
102684     } catch (Dali::DaliException e) {
102685       {
102686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102687       };
102688     } catch (...) {
102689       {
102690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102691       };
102692     }
102693   }
102694 }
102695
102696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102697   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102698   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102699   {
102700     try {
102701       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102702     } catch (std::out_of_range& e) {
102703       {
102704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102705       };
102706     } catch (std::exception& e) {
102707       {
102708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102709       };
102710     } catch (Dali::DaliException e) {
102711       {
102712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102713       };
102714     } catch (...) {
102715       {
102716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102717       };
102718     }
102719   }
102720   return (void*) result;
102721 }
102722
102723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102724 {
102725   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102726   {
102727     try {
102728       delete object;
102729     } catch (std::out_of_range& e) {
102730       {
102731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102732       };
102733     } catch (std::exception& e) {
102734       {
102735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102736       };
102737     } catch (Dali::DaliException e) {
102738       {
102739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102740       };
102741     } catch (...) {
102742       {
102743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102744       };
102745     }
102746   }
102747 }
102748
102749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102750 {
102751   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102752   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102753   {
102754     try {
102755       proxy->Connect(callback);
102756     } catch (std::out_of_range& e) {
102757       {
102758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102759       };
102760     } catch (std::exception& e) {
102761       {
102762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102763       };
102764     } catch (Dali::DaliException e) {
102765       {
102766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102767       };
102768     } catch (...) {
102769       {
102770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102771       };
102772     }
102773   }
102774 }
102775
102776
102777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
102778   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102779   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102780   {
102781     try {
102782       proxy->Disconnect(callback);
102783     } catch (std::out_of_range& e) {
102784       {
102785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102786       };
102787     } catch (std::exception& e) {
102788       {
102789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102790       };
102791     } catch (Dali::DaliException e) {
102792       {
102793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102794       };
102795     } catch (...) {
102796       {
102797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102798       };
102799     }
102800   }
102801 }
102802
102803 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
102804   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
102805   char * jresult = SWIG_csharp_string_callback((const char *)result);
102806   return jresult;
102807 }
102808
102809 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
102810   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
102811   return result;
102812 }
102813
102814
102815 struct NativeImageSourcePtrHandle
102816 {
102817   NativeImageSourcePtr Ptr;
102818 };
102819
102820 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
102821 {
102822   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
102823   return (NativeImageInterface*)(arg1);
102824 }
102825
102826 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
102827 {
102828   void* jresult;
102829   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
102830   {
102831     try {
102832       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
102833     }
102834     catch (std::out_of_range & e) {
102835       {
102836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102837       };
102838     }
102839     catch (std::exception & e) {
102840       {
102841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102842       };
102843     }
102844     catch (Dali::DaliException e) {
102845       {
102846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102847       };
102848     }
102849     catch (...) {
102850       {
102851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102852       };
102853     }
102854   }
102855   jresult = (void *)handle;
102856   return jresult;
102857 }
102858
102859 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
102860 {
102861   void* jresult;
102862   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
102863   jresult = (void*)( handle->Ptr.Get() );
102864   return jresult;
102865 }
102866
102867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
102868   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
102869   {
102870     try {
102871       delete arg1;
102872     }
102873     catch (std::out_of_range & e) {
102874       {
102875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
102876       };
102877     }
102878     catch (std::exception & e) {
102879       {
102880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
102881       };
102882     }
102883     catch (Dali::DaliException e) {
102884       {
102885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
102886       };
102887     }
102888     catch (...) {
102889       {
102890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
102891       };
102892     }
102893   }
102894 }
102895
102896 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
102897 {
102898   void* jresult;
102899   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
102900   uint16_t* arg2 = (uint16_t*)(jarg2);
102901   uint16_t* arg3 = (uint16_t*)(jarg3);
102902   uint16_t* arg4 = (uint16_t*)(jarg4);
102903   {
102904     try {
102905       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
102906     }
102907     catch (std::out_of_range & e) {
102908       {
102909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102910       };
102911     }
102912     catch (std::exception & e) {
102913       {
102914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102915       };
102916     }
102917     catch (Dali::DaliException e) {
102918       {
102919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102920       };
102921     }
102922     catch (...) {
102923       {
102924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102925       };
102926     }
102927   }
102928   return jresult;
102929 }
102930
102931 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
102932 {
102933   bool jresult;
102934   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
102935
102936   {
102937     try {
102938       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
102939     }
102940     catch (std::out_of_range & e) {
102941       {
102942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102943       };
102944     }
102945     catch (std::exception & e) {
102946       {
102947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102948       };
102949     }
102950     catch (Dali::DaliException e) {
102951       {
102952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102953       };
102954     }
102955     catch (...) {
102956       {
102957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102958       };
102959     }
102960   }
102961   return jresult;
102962 }
102963
102964
102965 #ifdef __cplusplus
102966 }
102967 #endif
102968