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-toolkit/devel-api/accessibility-manager/accessibility-manager.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 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 457 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 458 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 470 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 471
 472 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 473
 474 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 475 #include <dali/devel-api/adaptor-framework/image-loading.h>
 476
 477 #include <dali/public-api/events/mouse-button.h>
 478
 479 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 480 #include "web-view-signal-converter.h"
 481
 482 #include <dali/integration-api/debug.h>
 483
 484 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 485
 486 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 487
 488 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 489
 490
 491 #include <dali/devel-api/update/frame-callback-interface.h>
 492 #include <dali/devel-api/update/update-proxy.h>
 493
 494
 495 // add here SWIG version check
 496
 497 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 498 // disable Swig-dependent warnings
 499
 500 // 'identifier1' has C-linkage specified,
 501 // but returns UDT 'identifier2' which is incompatible with C
 502 #pragma warning(disable: 4190)
 503
 504 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 505 #pragma warning(disable: 4800)
 506
 507 // debug info too long etc etc
 508 #pragma warning(disable: 4786)
 509 #endif
 510
 511
 512 #include <stdexcept>
 513
 514
 515 #include <string>
 516
 517
 518 #include <vector>
 519 #include <algorithm>
 520 #include <stdexcept>
 521
 522
 523 #include <map>
 524 #include <algorithm>
 525 #include <stdexcept>
 526
 527
 528 #include <utility>
 529
 530
 531 typedef float floatp;
 532
 533 SWIGINTERN floatp *new_floatp(){
 534   return new float();
 535 }
 536 SWIGINTERN void delete_floatp(floatp *self){
 537   if (self) delete self;
 538 }
 539 SWIGINTERN void floatp_assign(floatp *self,float value){
 540   *self = value;
 541 }
 542 SWIGINTERN float floatp_value(floatp *self){
 543   return *self;
 544 }
 545 SWIGINTERN float *floatp_cast(floatp *self){
 546   return self;
 547 }
 548 SWIGINTERN floatp *floatp_frompointer(float *t){
 549   return (floatp *) t;
 550 }
 551
 552 typedef int intp;
 553
 554 SWIGINTERN intp *new_intp(){
 555   return new int();
 556 }
 557 SWIGINTERN void delete_intp(intp *self){
 558   if (self) delete self;
 559 }
 560 SWIGINTERN void intp_assign(intp *self,int value){
 561   *self = value;
 562 }
 563 SWIGINTERN int intp_value(intp *self){
 564   return *self;
 565 }
 566 SWIGINTERN int *intp_cast(intp *self){
 567   return self;
 568 }
 569 SWIGINTERN intp *intp_frompointer(int *t){
 570   return (intp *) t;
 571 }
 572
 573 typedef double doublep;
 574
 575 SWIGINTERN doublep *new_doublep(){
 576   return new double();
 577 }
 578 SWIGINTERN void delete_doublep(doublep *self){
 579   if (self) delete self;
 580 }
 581 SWIGINTERN void doublep_assign(doublep *self,double value){
 582   *self = value;
 583 }
 584 SWIGINTERN double doublep_value(doublep *self){
 585   return *self;
 586 }
 587 SWIGINTERN double *doublep_cast(doublep *self){
 588   return self;
 589 }
 590 SWIGINTERN doublep *doublep_frompointer(double *t){
 591   return (doublep *) t;
 592 }
 593
 594 typedef unsigned int uintp;
 595
 596 SWIGINTERN uintp *new_uintp(){
 597   return new unsigned int();
 598 }
 599 SWIGINTERN void delete_uintp(uintp *self){
 600   if (self) delete self;
 601 }
 602 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 603   *self = value;
 604 }
 605 SWIGINTERN unsigned int uintp_value(uintp *self){
 606   return *self;
 607 }
 608 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 609   return self;
 610 }
 611 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 612   return (uintp *) t;
 613 }
 614
 615 typedef unsigned short ushortp;
 616
 617 SWIGINTERN ushortp *new_ushortp(){
 618   return new unsigned short();
 619 }
 620 SWIGINTERN void delete_ushortp(ushortp *self){
 621   if (self) delete self;
 622 }
 623 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 624   *self = value;
 625 }
 626 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 627   return *self;
 628 }
 629 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 630   return self;
 631 }
 632 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 633   return (ushortp *) t;
 634 }
 635
 636 unsigned int int_to_uint(int x) {
 637    return (unsigned int) x;
 638 }
 639
 640
 641 using namespace Dali;
 642 using namespace Dali::Toolkit;
 643
 644 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 645 {
 646   bool result = false;
 647   try
 648   {
 649     // C++ code. DALi uses Handle <-> Body design pattern.
 650     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 651     // Handles in DALi can be converted into a boolean type
 652     // to check if the handle has a valid body attached to it.
 653     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 654     if( *self )
 655     {
 656       result = true;
 657     }
 658     else
 659     {
 660       result = false;
 661     }
 662   }
 663   catch (std::out_of_range& e)
 664   {
 665     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 666     return 0;
 667   }
 668   catch (std::exception& e)
 669   {
 670     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 671     return 0;
 672   }
 673   catch (DaliException e)
 674   {
 675     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 676     return 0;
 677   }
 678   catch (...)
 679   {
 680     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 681     return 0;
 682   }
 683   return result;
 684 }
 685
 686 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 687 {
 688   bool result = false;
 689   try
 690   {
 691     // C++ code. Check if two handles reference the same implemtion
 692     if( *self == rhs)
 693     {
 694       result = true;
 695     }
 696     else
 697     {
 698       result = false;
 699     }
 700   }
 701   catch (std::out_of_range& e)
 702   {
 703     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 704     return 0;
 705   }
 706   catch (std::exception& e)
 707   {
 708     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 709     return 0;
 710   }
 711   catch (DaliException e)
 712   {
 713     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 714     return 0;
 715   }
 716   catch (...)
 717   {
 718     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 719     return 0;
 720   }
 721   return result;
 722 }
 723
 724
 725 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 726      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 727    }
 728 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){
 729      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 730    }
 731 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 732         std::vector< Dali::TouchPoint >* pv = 0;
 733         if (capacity >= 0) {
 734           pv = new std::vector< Dali::TouchPoint >();
 735           pv->reserve(capacity);
 736        } else {
 737           throw std::out_of_range("capacity");
 738        }
 739        return pv;
 740       }
 741 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 742         if (index>=0 && index<(int)self->size())
 743           return (*self)[index];
 744         else
 745           throw std::out_of_range("index");
 746       }
 747 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 748         if (index>=0 && index<(int)self->size())
 749           return (*self)[index];
 750         else
 751           throw std::out_of_range("index");
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 754         if (index>=0 && index<(int)self->size())
 755           (*self)[index] = val;
 756         else
 757           throw std::out_of_range("index");
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 760         self->insert(self->end(), values.begin(), values.end());
 761       }
 762 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 763         if (index < 0)
 764           throw std::out_of_range("index");
 765         if (count < 0)
 766           throw std::out_of_range("count");
 767         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 768           throw std::invalid_argument("invalid range");
 769         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 772         if (index>=0 && index<(int)self->size()+1)
 773           self->insert(self->begin()+index, x);
 774         else
 775           throw std::out_of_range("index");
 776       }
 777 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 778         if (index>=0 && index<(int)self->size()+1)
 779           self->insert(self->begin()+index, values.begin(), values.end());
 780         else
 781           throw std::out_of_range("index");
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 784         if (index>=0 && index<(int)self->size())
 785           self->erase(self->begin() + index);
 786         else
 787           throw std::out_of_range("index");
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 790         if (index < 0)
 791           throw std::out_of_range("index");
 792         if (count < 0)
 793           throw std::out_of_range("count");
 794         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 795           throw std::invalid_argument("invalid range");
 796         self->erase(self->begin()+index, self->begin()+index+count);
 797       }
 798 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 799         if (count < 0)
 800           throw std::out_of_range("count");
 801         return new std::vector< Dali::TouchPoint >(count, value);
 802       }
 803 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 804         std::reverse(self->begin(), self->end());
 805       }
 806 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 807         if (index < 0)
 808           throw std::out_of_range("index");
 809         if (count < 0)
 810           throw std::out_of_range("count");
 811         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 812           throw std::invalid_argument("invalid range");
 813         std::reverse(self->begin()+index, self->begin()+index+count);
 814       }
 815 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 816         if (index < 0)
 817           throw std::out_of_range("index");
 818         if (index+values.size() > self->size())
 819           throw std::out_of_range("index");
 820         std::copy(values.begin(), values.end(), self->begin()+index);
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 839          return self->Empty();
 840       }
 841 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 842         return self->GetConnectionCount();
 843       }
 844 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 845           self->Connect( func );
 846       }
 847 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 848           self->Disconnect( func );
 849       }
 850 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 855          return self->Empty();
 856       }
 857 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){
 858         return self->GetConnectionCount();
 859       }
 860 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 *)){
 861           self->Connect( func );
 862       }
 863 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 *)){
 864           self->Disconnect( func );
 865       }
 866 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){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 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){
 887          return self->Empty();
 888       }
 889 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){
 890         return self->GetConnectionCount();
 891       }
 892 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 &)){
 893         self->Connect( func );
 894       }
 895 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 &)){
 896         self->Disconnect( func );
 897       }
 898 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){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 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){
 903          return self->Empty();
 904       }
 905 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){
 906         return self->GetConnectionCount();
 907       }
 908 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 &)){
 909         self->Connect( func );
 910       }
 911 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 &)){
 912         self->Disconnect( func );
 913       }
 914 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){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 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){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924         self->Connect( func );
 925       }
 926 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 &)){
 927         self->Disconnect( func );
 928       }
 929 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){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 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){
 933          return self->Empty();
 934       }
 935 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){
 936         return self->GetConnectionCount();
 937       }
 938 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 &)){
 939         self->Connect( func );
 940       }
 941 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 &)){
 942         self->Disconnect( func );
 943       }
 944 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){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 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){
 967         return self->GetConnectionCount();
 968       }
 969 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 &)){
 970           self->Connect( func );
 971       }
 972 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 &)){
 973           self->Disconnect( func );
 974       }
 975 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){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 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){
 983         return self->GetConnectionCount();
 984       }
 985 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 &)){
 986           self->Connect( func );
 987       }
 988 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 &)){
 989           self->Disconnect( func );
 990       }
 991 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){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 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){
 999         return self->GetConnectionCount();
1000       }
1001 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 &)){
1002           self->Connect( func );
1003       }
1004 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 &)){
1005           self->Disconnect( func );
1006       }
1007 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){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 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){
1012          return self->Empty();
1013       }
1014 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){
1015         return self->GetConnectionCount();
1016       }
1017 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 &)){
1018         self->Connect( func );
1019       }
1020 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 &)){
1021         self->Disconnect( func );
1022       }
1023 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){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 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){
1028          return self->Empty();
1029       }
1030 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){
1031         return self->GetConnectionCount();
1032       }
1033 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 &)){
1034         self->Connect( func );
1035       }
1036 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 &)){
1037         self->Disconnect( func );
1038       }
1039 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){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 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){
1044          return self->Empty();
1045       }
1046 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){
1047         return self->GetConnectionCount();
1048       }
1049 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 &)){
1050         self->Connect( func );
1051       }
1052 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 &)){
1053         self->Disconnect( func );
1054       }
1055 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){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 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){
1060          return self->Empty();
1061       }
1062 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){
1063         return self->GetConnectionCount();
1064       }
1065 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)){
1066           return self->Connect( func );
1067       }
1068 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)){
1069           self->Disconnect( func );
1070       }
1071 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){
1072           self->Emit( arg1, arg3 );
1073       }
1074 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){
1075          return self->Empty();
1076       }
1077 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){
1078         return self->GetConnectionCount();
1079       }
1080 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)){
1081           return self->Connect( func );
1082       }
1083 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)){
1084           self->Disconnect( func );
1085       }
1086 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){
1087           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1088 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1089       }
1090
1091 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1092          return self->Empty();
1093       }
1094 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1095         return self->GetConnectionCount();
1096       }
1097 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1098           self->Connect( func );
1099       }
1100 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1101           self->Disconnect( func );
1102       }
1103 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1104           return self->Emit();
1105       }
1106
1107 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1108         std::vector< unsigned int >* pv = 0;
1109         if (capacity >= 0) {
1110           pv = new std::vector< unsigned int >();
1111           pv->reserve(capacity);
1112        } else {
1113           throw std::out_of_range("capacity");
1114        }
1115        return pv;
1116       }
1117 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1118         if (index>=0 && index<(int)self->size())
1119           return (*self)[index];
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1124         if (index>=0 && index<(int)self->size())
1125           return (*self)[index];
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1130         if (index>=0 && index<(int)self->size())
1131           (*self)[index] = val;
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1136         self->insert(self->end(), values.begin(), values.end());
1137       }
1138 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1139         if (index < 0)
1140           throw std::out_of_range("index");
1141         if (count < 0)
1142           throw std::out_of_range("count");
1143         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1144           throw std::invalid_argument("invalid range");
1145         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1148         if (index>=0 && index<(int)self->size()+1)
1149           self->insert(self->begin()+index, x);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1154         if (index>=0 && index<(int)self->size()+1)
1155           self->insert(self->begin()+index, values.begin(), values.end());
1156         else
1157           throw std::out_of_range("index");
1158       }
1159 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1160         if (index>=0 && index<(int)self->size())
1161           self->erase(self->begin() + index);
1162         else
1163           throw std::out_of_range("index");
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1166         if (index < 0)
1167           throw std::out_of_range("index");
1168         if (count < 0)
1169           throw std::out_of_range("count");
1170         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1171           throw std::invalid_argument("invalid range");
1172         self->erase(self->begin()+index, self->begin()+index+count);
1173       }
1174 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1175         if (count < 0)
1176           throw std::out_of_range("count");
1177         return new std::vector< unsigned int >(count, value);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1180         std::reverse(self->begin(), self->end());
1181       }
1182 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1183         if (index < 0)
1184           throw std::out_of_range("index");
1185         if (count < 0)
1186           throw std::out_of_range("count");
1187         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1188           throw std::invalid_argument("invalid range");
1189         std::reverse(self->begin()+index, self->begin()+index+count);
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (index+values.size() > self->size())
1195           throw std::out_of_range("index");
1196         std::copy(values.begin(), values.end(), self->begin()+index);
1197       }
1198 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1199         return std::find(self->begin(), self->end(), value) != self->end();
1200       }
1201 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1202         int index = -1;
1203         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1204         if (it != self->end())
1205           index = (int)(it - self->begin());
1206         return index;
1207       }
1208 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1209         int index = -1;
1210         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1211         if (rit != self->rend())
1212           index = (int)(self->rend() - 1 - rit);
1213         return index;
1214       }
1215 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1216         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1217         if (it != self->end()) {
1218           self->erase(it);
1219           return true;
1220         }
1221         return false;
1222       }
1223 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){
1224         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1225         if (capacity >= 0) {
1226           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1227           pv->reserve(capacity);
1228        } else {
1229           throw std::out_of_range("capacity");
1230        }
1231        return pv;
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size())
1235           return (*self)[index];
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 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){
1240         if (index>=0 && index<(int)self->size())
1241           return (*self)[index];
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 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){
1246         if (index>=0 && index<(int)self->size())
1247           (*self)[index] = val;
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 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){
1252         self->insert(self->end(), values.begin(), values.end());
1253       }
1254 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){
1255         if (index < 0)
1256           throw std::out_of_range("index");
1257         if (count < 0)
1258           throw std::out_of_range("count");
1259         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1260           throw std::invalid_argument("invalid range");
1261         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size()+1)
1265           self->insert(self->begin()+index, x);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1270         if (index>=0 && index<(int)self->size()+1)
1271           self->insert(self->begin()+index, values.begin(), values.end());
1272         else
1273           throw std::out_of_range("index");
1274       }
1275 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){
1276         if (index>=0 && index<(int)self->size())
1277           self->erase(self->begin() + index);
1278         else
1279           throw std::out_of_range("index");
1280       }
1281 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){
1282         if (index < 0)
1283           throw std::out_of_range("index");
1284         if (count < 0)
1285           throw std::out_of_range("count");
1286         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1287           throw std::invalid_argument("invalid range");
1288         self->erase(self->begin()+index, self->begin()+index+count);
1289       }
1290 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){
1291         if (count < 0)
1292           throw std::out_of_range("count");
1293         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1294       }
1295 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){
1296         std::reverse(self->begin(), self->end());
1297       }
1298 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){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         std::reverse(self->begin()+index, self->begin()+index+count);
1306       }
1307 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){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (index+values.size() > self->size())
1311           throw std::out_of_range("index");
1312         std::copy(values.begin(), values.end(), self->begin()+index);
1313       }
1314 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1315         std::vector< Dali::Actor >* pv = 0;
1316         if (capacity >= 0) {
1317           pv = new std::vector< Dali::Actor >();
1318           pv->reserve(capacity);
1319        } else {
1320           throw std::out_of_range("capacity");
1321        }
1322        return pv;
1323       }
1324 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1325         if (index>=0 && index<(int)self->size())
1326           return (*self)[index];
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1331         if (index>=0 && index<(int)self->size())
1332           return (*self)[index];
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1337         if (index>=0 && index<(int)self->size())
1338           (*self)[index] = val;
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1343         self->insert(self->end(), values.begin(), values.end());
1344       }
1345 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1346         if (index < 0)
1347           throw std::out_of_range("index");
1348         if (count < 0)
1349           throw std::out_of_range("count");
1350         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1351           throw std::invalid_argument("invalid range");
1352         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1355         if (index>=0 && index<(int)self->size()+1)
1356           self->insert(self->begin()+index, x);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1361         if (index>=0 && index<(int)self->size()+1)
1362           self->insert(self->begin()+index, values.begin(), values.end());
1363         else
1364           throw std::out_of_range("index");
1365       }
1366 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1367         if (index>=0 && index<(int)self->size())
1368           self->erase(self->begin() + index);
1369         else
1370           throw std::out_of_range("index");
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1373         if (index < 0)
1374           throw std::out_of_range("index");
1375         if (count < 0)
1376           throw std::out_of_range("count");
1377         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1378           throw std::invalid_argument("invalid range");
1379         self->erase(self->begin()+index, self->begin()+index+count);
1380       }
1381 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1382         if (count < 0)
1383           throw std::out_of_range("count");
1384         return new std::vector< Dali::Actor >(count, value);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1387         std::reverse(self->begin(), self->end());
1388       }
1389 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1390         if (index < 0)
1391           throw std::out_of_range("index");
1392         if (count < 0)
1393           throw std::out_of_range("count");
1394         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1395           throw std::invalid_argument("invalid range");
1396         std::reverse(self->begin()+index, self->begin()+index+count);
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (index+values.size() > self->size())
1402           throw std::out_of_range("index");
1403         std::copy(values.begin(), values.end(), self->begin()+index);
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 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 &)){
1412           self->Connect( func );
1413       }
1414 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 &)){
1415           self->Disconnect( func );
1416       }
1417 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){
1418           return self->Emit( arg );
1419       }
1420 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){
1421          return self->Empty();
1422       }
1423 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){
1424         return self->GetConnectionCount();
1425       }
1426 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)){
1427         self->Connect( func );
1428       }
1429 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)){
1430         self->Disconnect( func );
1431       }
1432 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){
1433         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1434 /*@SWIG@*/ self->Emit( arg1, arg2 );
1435       }
1436 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1437          return self->Empty();
1438       }
1439 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){
1440         return self->GetConnectionCount();
1441       }
1442 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)){
1443         self->Connect( func );
1444       }
1445 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)){
1446         self->Disconnect( func );
1447       }
1448 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){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 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)){
1459         self->Connect( func );
1460       }
1461 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)){
1462         self->Disconnect( func );
1463       }
1464 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){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 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){
1469          return self->Empty();
1470       }
1471 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){
1472         return self->GetConnectionCount();
1473       }
1474 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)){
1475         self->Connect( func );
1476       }
1477 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)){
1478         self->Disconnect( func );
1479       }
1480 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){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 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)){
1491           self->Connect( func );
1492       }
1493 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)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1497           return self->Emit( arg );
1498       }
1499 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1500          return self->Empty();
1501       }
1502 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1503         return self->GetConnectionCount();
1504       }
1505 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)){
1506           self->Connect( func );
1507       }
1508 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)){
1509           self->Disconnect( func );
1510       }
1511 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1512           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1513 /*@SWIG@*/ self->Emit( arg );
1514       }
1515 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){
1516          return self->Empty();
1517       }
1518 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){
1519         return self->GetConnectionCount();
1520       }
1521 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)){
1522           return self->Connect( func );
1523       }
1524 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)){
1525           self->Disconnect( func );
1526       }
1527 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){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1530       }
1531 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1532          return self->Empty();
1533       }
1534 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1535         return self->GetConnectionCount();
1536       }
1537 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)){
1538           self->Connect( func );
1539       }
1540 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)){
1541           self->Disconnect( func );
1542       }
1543 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg );
1546       }
1547 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){
1548          return self->Empty();
1549       }
1550 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){
1551         return self->GetConnectionCount();
1552       }
1553 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)){
1554           return self->Connect( func );
1555       }
1556 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)){
1557           self->Disconnect( func );
1558       }
1559 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){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1562       }
1563 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){
1564          return self->Empty();
1565       }
1566 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){
1567         return self->GetConnectionCount();
1568       }
1569 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 &)){
1570           self->Connect( func );
1571       }
1572 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 &)){
1573           self->Disconnect( func );
1574       }
1575 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){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1580          return self->Empty();
1581       }
1582 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){
1583         return self->GetConnectionCount();
1584       }
1585 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 &)){
1586           self->Connect( func );
1587       }
1588 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 &)){
1589           self->Disconnect( func );
1590       }
1591 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){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595
1596
1597 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){
1598          return self->Empty();
1599       }
1600 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){
1601         return self->GetConnectionCount();
1602       }
1603 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 &)){
1604         self->Connect( func );
1605       }
1606 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 &)){
1607         self->Disconnect( func );
1608       }
1609 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){
1610         return self->Emit( arg1, arg2 );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 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)){
1619           self->Connect( func );
1620       }
1621 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)){
1622           self->Disconnect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1625           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1626 /*@SWIG@*/ self->Emit( arg );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 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 &)){
1635           self->Connect( func );
1636       }
1637 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 &)){
1638           self->Disconnect( func );
1639       }
1640 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){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1645          return self->Empty();
1646       }
1647 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){
1648         return self->GetConnectionCount();
1649       }
1650 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)){
1651         self->Connect( func );
1652       }
1653 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)){
1654         self->Disconnect( func );
1655       }
1656 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){
1657         return self->Emit( arg1, arg2 );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1660          return self->Empty();
1661       }
1662 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){
1663         return self->GetConnectionCount();
1664       }
1665 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)){
1666         self->Connect( func );
1667       }
1668 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)){
1669         self->Disconnect( func );
1670       }
1671 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){
1672         return self->Emit( arg1, arg2 );
1673       }
1674
1675 /* ---------------------------------------------------
1676  * C++ director class methods
1677  * --------------------------------------------------- */
1678
1679 #include "dali_wrap.h"
1680
1681 /*
1682  *  Widget director
1683  */
1684 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1685   swig_init_callbacks();
1686 }
1687
1688 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1689 }
1690
1691 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1692   char * jcontentInfo = 0 ;
1693   void * jwindow  ;
1694
1695   if (!swig_callbackOnCreate) {
1696     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1697     return;
1698   } else {
1699     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1700     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1701     swig_callbackOnCreate(jcontentInfo, jwindow);
1702   }
1703 }
1704
1705 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1706   char * jcontentInfo = 0 ;
1707   int jtype  ;
1708
1709   if (!swig_callbackOnTerminate) {
1710     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1711     return;
1712   } else {
1713     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1714     jtype = (int)type;
1715     swig_callbackOnTerminate(jcontentInfo, jtype);
1716   }
1717 }
1718
1719 void SwigDirector_WidgetImpl::OnPause() {
1720   if (!swig_callbackOnPause) {
1721     Dali::Internal::Adaptor::Widget::OnPause();
1722     return;
1723   } else {
1724     swig_callbackOnPause();
1725   }
1726 }
1727
1728 void SwigDirector_WidgetImpl::OnResume() {
1729   if (!swig_callbackOnResume) {
1730     Dali::Internal::Adaptor::Widget::OnResume();
1731     return;
1732   } else {
1733     swig_callbackOnResume();
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1738   void * jwindow  ;
1739
1740   if (!swig_callbackOnResize) {
1741     Dali::Internal::Adaptor::Widget::OnResize(window);
1742     return;
1743   } else {
1744     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1745     swig_callbackOnResize(jwindow);
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1750   char * jcontentInfo = 0 ;
1751   int jforce  ;
1752
1753   if (!swig_callbackOnUpdate) {
1754     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1755     return;
1756   } else {
1757     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1758     jforce = force;
1759     swig_callbackOnUpdate(jcontentInfo, jforce);
1760   }
1761 }
1762
1763 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1764   void * jslotObserver = 0 ;
1765   void * jcallback = 0 ;
1766
1767   if (!swig_callbackSignalConnected) {
1768     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1769     return;
1770   } else {
1771     jslotObserver = (void *) slotObserver;
1772     jcallback = (void *) callback;
1773     swig_callbackSignalConnected(jslotObserver, jcallback);
1774   }
1775 }
1776
1777 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1778   void * jslotObserver = 0 ;
1779   void * jcallback = 0 ;
1780
1781   if (!swig_callbackSignalDisconnected) {
1782     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1783     return;
1784   } else {
1785     jslotObserver = (void *) slotObserver;
1786     jcallback = (void *) callback;
1787     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1788   }
1789 }
1790
1791 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) {
1792
1793   swig_callbackOnCreate = callbackOnCreate;
1794   swig_callbackOnTerminate = callbackOnTerminate;
1795   swig_callbackOnPause = callbackOnPause;
1796   swig_callbackOnResume = callbackOnResume;
1797   swig_callbackOnResize = callbackOnResize;
1798   swig_callbackOnUpdate = callbackOnUpdate;
1799   swig_callbackSignalConnected = callbackSignalConnected;
1800   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1801 }
1802
1803 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1804   swig_callbackOnCreate = 0;
1805   swig_callbackOnTerminate = 0;
1806   swig_callbackOnPause = 0;
1807   swig_callbackOnResume = 0;
1808   swig_callbackOnResize = 0;
1809   swig_callbackOnUpdate = 0;
1810   swig_callbackSignalConnected = 0;
1811   swig_callbackSignalDisconnected = 0;
1812 }
1813
1814
1815 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1816   swig_init_callbacks();
1817 }
1818
1819 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1820
1821 }
1822
1823
1824 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1825   int jdepth  ;
1826
1827   if (!swig_callbackOnSceneConnection) {
1828     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1829     return;
1830   } else {
1831     jdepth = depth;
1832     swig_callbackOnSceneConnection(jdepth);
1833   }
1834 }
1835
1836 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1837   if (!swig_callbackOnSceneDisconnection) {
1838     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1839     return;
1840   } else {
1841     swig_callbackOnSceneDisconnection();
1842   }
1843 }
1844
1845 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1846   void * jchild = 0 ;
1847
1848   if (!swig_callbackOnChildAdd) {
1849     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1850     return;
1851   } else {
1852     jchild = (Dali::Actor *) &child;
1853     swig_callbackOnChildAdd(jchild);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1858   void * jchild = 0 ;
1859
1860   if (!swig_callbackOnChildRemove) {
1861     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1862     return;
1863   } else {
1864     jchild = (Dali::Actor *) &child;
1865     swig_callbackOnChildRemove(jchild);
1866   }
1867 }
1868
1869 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1870   int jindex  ;
1871   void * jpropertyValue  ;
1872
1873   if (!swig_callbackOnPropertySet) {
1874     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1875     return;
1876   } else {
1877     jindex = index;
1878     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1879     swig_callbackOnPropertySet(jindex, jpropertyValue);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1884   void * jtargetSize = 0 ;
1885
1886   if (!swig_callbackOnSizeSet) {
1887     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1888     return;
1889   } else {
1890     jtargetSize = (Dali::Vector3 *) &targetSize;
1891     swig_callbackOnSizeSet(jtargetSize);
1892   }
1893 }
1894
1895 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1896   void * janimation = 0 ;
1897   void * jtargetSize = 0 ;
1898
1899   if (!swig_callbackOnSizeAnimation) {
1900     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1901     return;
1902   } else {
1903     janimation = (Dali::Animation *) &animation;
1904     jtargetSize = (Dali::Vector3 *) &targetSize;
1905     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1906   }
1907 }
1908
1909 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1910   bool c_result = SwigValueInit< bool >() ;
1911   unsigned int jresult = 0 ;
1912   void * jarg0 = 0 ;
1913
1914   if (!swig_callbackOnTouchEvent) {
1915     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1916   } else {
1917     jarg0 = (Dali::TouchEvent *) &event;
1918     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1919     c_result = jresult ? true : false;
1920   }
1921   return c_result;
1922 }
1923
1924 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1925   bool c_result = SwigValueInit< bool >() ;
1926   unsigned int jresult = 0 ;
1927   void * jarg0 = 0 ;
1928
1929   if (!swig_callbackOnHoverEvent) {
1930     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1931   } else {
1932     jarg0 = (Dali::HoverEvent *) &event;
1933     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1934     c_result = jresult ? true : false;
1935   }
1936   return c_result;
1937 }
1938
1939 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1940   bool c_result = SwigValueInit< bool >() ;
1941   unsigned int jresult = 0 ;
1942   void * jarg0 = 0 ;
1943
1944   if (!swig_callbackOnKeyEvent) {
1945     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1946   } else {
1947     jarg0 = (Dali::KeyEvent *) &event;
1948     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1949     c_result = jresult ? true : false;
1950   }
1951   return c_result;
1952 }
1953
1954 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1955   bool c_result = SwigValueInit< bool >() ;
1956   unsigned int jresult = 0 ;
1957   void * jarg0 = 0 ;
1958
1959   if (!swig_callbackOnWheelEvent) {
1960     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1961   } else {
1962     jarg0 = (Dali::WheelEvent *) &event;
1963     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1964     c_result = jresult ? true : false;
1965   }
1966   return c_result;
1967 }
1968
1969 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1970   void * jsize = 0 ;
1971   void * jcontainer = 0 ;
1972
1973   if (!swig_callbackOnRelayout) {
1974     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1975     return;
1976   } else {
1977     jsize = (Dali::Vector2 *) &size;
1978     jcontainer = (Dali::RelayoutContainer *) &container;
1979     swig_callbackOnRelayout(jsize, jcontainer);
1980   }
1981 }
1982
1983 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1984   int jpolicy  ;
1985   int jdimension  ;
1986
1987   if (!swig_callbackOnSetResizePolicy) {
1988     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1989     return;
1990   } else {
1991     jpolicy = (int)policy;
1992     jdimension = (int)dimension;
1993     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1994   }
1995 }
1996
1997 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1998   Dali::Vector3 c_result ;
1999   void * jresult = 0 ;
2000
2001   if (!swig_callbackGetNaturalSize) {
2002     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2003   } else {
2004     jresult = (void *) swig_callbackGetNaturalSize();
2005     if (!jresult) {
2006       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2007       return c_result;
2008     }
2009     c_result = *(Dali::Vector3 *)jresult;
2010   }
2011   return c_result;
2012 }
2013
2014 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2015   float c_result = SwigValueInit< float >() ;
2016   float jresult = 0 ;
2017   void * jchild = 0 ;
2018   int jdimension  ;
2019
2020   if (!swig_callbackCalculateChildSize) {
2021     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2022   } else {
2023     jchild = (Dali::Actor *) &child;
2024     jdimension = (int)dimension;
2025     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2026     c_result = (float)jresult;
2027   }
2028   return c_result;
2029 }
2030
2031 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2032   float c_result = SwigValueInit< float >() ;
2033   float jresult = 0 ;
2034   float jwidth  ;
2035
2036   if (!swig_callbackGetHeightForWidth) {
2037     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2038   } else {
2039     jwidth = width;
2040     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2041     c_result = (float)jresult;
2042   }
2043   return c_result;
2044 }
2045
2046 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2047   float c_result = SwigValueInit< float >() ;
2048   float jresult = 0 ;
2049   float jheight  ;
2050
2051   if (!swig_callbackGetWidthForHeight) {
2052     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2053   } else {
2054     jheight = height;
2055     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2056     c_result = (float)jresult;
2057   }
2058   return c_result;
2059 }
2060
2061 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2062   bool c_result = SwigValueInit< bool >() ;
2063   unsigned int jresult = 0 ;
2064   int jdimension  ;
2065
2066   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2067     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2068   } else {
2069     jdimension = (int)dimension;
2070     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2071     c_result = jresult ? true : false;
2072   }
2073   return c_result;
2074 }
2075
2076 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2077   int jdimension  ;
2078
2079   if (!swig_callbackOnCalculateRelayoutSize) {
2080     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2081     return;
2082   } else {
2083     jdimension = (int)dimension;
2084     swig_callbackOnCalculateRelayoutSize(jdimension);
2085   }
2086 }
2087
2088 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2089   float jsize  ;
2090   int jdimension  ;
2091
2092   if (!swig_callbackOnLayoutNegotiated) {
2093     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2094     return;
2095   } else {
2096     jsize = size;
2097     jdimension = (int)dimension;
2098     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2099   }
2100 }
2101
2102 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2103   return Dali::CustomActorImpl::GetExtension();
2104 }
2105
2106 void SwigDirector_ViewImpl::OnInitialize() {
2107   if (!swig_callbackOnInitialize) {
2108     Dali::Toolkit::Internal::Control::OnInitialize();
2109     return;
2110   } else {
2111     swig_callbackOnInitialize();
2112   }
2113 }
2114
2115 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2116   void * jstyleManager  ;
2117   int jchange  ;
2118
2119   if (!swig_callbackOnStyleChange) {
2120     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2121     return;
2122   } else {
2123     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2124     jchange = (int)change;
2125     swig_callbackOnStyleChange(jstyleManager, jchange);
2126   }
2127 }
2128
2129 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2130   bool c_result = SwigValueInit< bool >() ;
2131   unsigned int jresult = 0 ;
2132
2133   if (!swig_callbackOnAccessibilityActivated) {
2134     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2135   } else {
2136     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2137     c_result = jresult ? true : false;
2138   }
2139   return c_result;
2140 }
2141
2142 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2143   bool c_result = SwigValueInit< bool >() ;
2144   unsigned int jresult = 0 ;
2145   void * jgesture  ;
2146
2147   if (!swig_callbackOnAccessibilityPan) {
2148     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2149   } else {
2150     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2151     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2158   bool c_result = SwigValueInit< bool >() ;
2159   unsigned int jresult = 0 ;
2160   void * jtouchEvent = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityTouch) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2164   } else {
2165     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2166     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2167     c_result = jresult ? true : false;
2168   }
2169   return c_result;
2170 }
2171
2172 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2173   bool c_result = SwigValueInit< bool >() ;
2174   unsigned int jresult = 0 ;
2175   unsigned int jisIncrease  ;
2176
2177   if (!swig_callbackOnAccessibilityValueChange) {
2178     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2179   } else {
2180     jisIncrease = isIncrease;
2181     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2182     c_result = jresult ? true : false;
2183   }
2184   return c_result;
2185 }
2186
2187 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2188   bool c_result = SwigValueInit< bool >() ;
2189   unsigned int jresult = 0 ;
2190
2191   if (!swig_callbackOnAccessibilityZoom) {
2192     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2193   } else {
2194     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2195     c_result = jresult ? true : false;
2196   }
2197   return c_result;
2198 }
2199
2200 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2201   if (!swig_callbackOnKeyInputFocusGained) {
2202     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2203     return;
2204   } else {
2205     swig_callbackOnKeyInputFocusGained();
2206   }
2207 }
2208
2209 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2210   if (!swig_callbackOnKeyInputFocusLost) {
2211     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2212     return;
2213   } else {
2214     swig_callbackOnKeyInputFocusLost();
2215   }
2216 }
2217
2218 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2219   Dali::Actor c_result ;
2220   void * jresult = 0 ;
2221   void * jcurrentFocusedActor  ;
2222   int jdirection  ;
2223   unsigned int jloopEnabled  ;
2224
2225   if (!swig_callbackGetNextKeyboardFocusableActor) {
2226     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2227   } else {
2228     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2229     jdirection = (int)direction;
2230     jloopEnabled = loopEnabled;
2231     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2232     if (!jresult) {
2233       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2234       return c_result;
2235     }
2236     c_result = *(Dali::Actor *)jresult;
2237   }
2238   return c_result;
2239 }
2240
2241 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2242   void * jcommitedFocusableActor  ;
2243
2244   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2245     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2246     return;
2247   } else {
2248     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2249     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2250   }
2251 }
2252
2253 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2254   bool c_result = SwigValueInit< bool >() ;
2255   unsigned int jresult = 0 ;
2256
2257   if (!swig_callbackOnKeyboardEnter) {
2258     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2259   } else {
2260     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2261     c_result = jresult ? true : false;
2262   }
2263   return c_result;
2264 }
2265
2266 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2267   void * jpinch = 0 ;
2268
2269   if (!swig_callbackOnPinch) {
2270     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2271     return;
2272   } else {
2273     jpinch = (Dali::PinchGesture *) &pinch;
2274     swig_callbackOnPinch(jpinch);
2275   }
2276 }
2277
2278 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2279   void * jpan = 0 ;
2280
2281   if (!swig_callbackOnPan) {
2282     Dali::Toolkit::Internal::Control::OnPan(pan);
2283     return;
2284   } else {
2285     jpan = (Dali::PanGesture *) &pan;
2286     swig_callbackOnPan(jpan);
2287   }
2288 }
2289
2290 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2291   void * jtap = 0 ;
2292
2293   if (!swig_callbackOnTap) {
2294     Dali::Toolkit::Internal::Control::OnTap(tap);
2295     return;
2296   } else {
2297     jtap = (Dali::TapGesture *) &tap;
2298     swig_callbackOnTap(jtap);
2299   }
2300 }
2301
2302 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2303   void * jlongPress = 0 ;
2304
2305   if (!swig_callbackOnLongPress) {
2306     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2307     return;
2308   } else {
2309     jlongPress = (Dali::LongPressGesture *) &longPress;
2310     swig_callbackOnLongPress(jlongPress);
2311   }
2312 }
2313
2314 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2315   void * jslotObserver = 0 ;
2316   void * jcallback = 0 ;
2317
2318   if (!swig_callbackSignalConnected) {
2319     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2320     return;
2321   } else {
2322     jslotObserver = (void *) slotObserver;
2323     jcallback = (void *) callback;
2324     swig_callbackSignalConnected(jslotObserver, jcallback);
2325   }
2326 }
2327
2328 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2329   void * jslotObserver = 0 ;
2330   void * jcallback = 0 ;
2331
2332   if (!swig_callbackSignalDisconnected) {
2333     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2334     return;
2335   } else {
2336     jslotObserver = (void *) slotObserver;
2337     jcallback = (void *) callback;
2338     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2339   }
2340 }
2341
2342 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2343   return Dali::Toolkit::Internal::Control::GetControlExtension();
2344 }
2345
2346 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnSceneConnection, SWIG_Callback1_t callbackOnSceneDisconnection, 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_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) {
2347   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2348   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2349   swig_callbackOnChildAdd = callbackOnChildAdd;
2350   swig_callbackOnChildRemove = callbackOnChildRemove;
2351   swig_callbackOnPropertySet = callbackOnPropertySet;
2352   swig_callbackOnSizeSet = callbackOnSizeSet;
2353   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2354   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2355   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2356   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2357   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2358   swig_callbackOnRelayout = callbackOnRelayout;
2359   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2360   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2361   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2362   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2363   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2364   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2365   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2366   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2367   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2368   swig_callbackOnInitialize = callbackOnInitialize;
2369   swig_callbackOnStyleChange = callbackOnStyleChange;
2370   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2371   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2372   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2373   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2374   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2375   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2376   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2377   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2378   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2379   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2380   swig_callbackOnPinch = callbackOnPinch;
2381   swig_callbackOnPan = callbackOnPan;
2382   swig_callbackOnTap = callbackOnTap;
2383   swig_callbackOnLongPress = callbackOnLongPress;
2384   swig_callbackSignalConnected = callbackSignalConnected;
2385   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2386 }
2387
2388 void SwigDirector_ViewImpl::swig_init_callbacks() {
2389   swig_callbackOnSceneConnection = 0;
2390   swig_callbackOnSceneDisconnection = 0;
2391   swig_callbackOnChildAdd = 0;
2392   swig_callbackOnChildRemove = 0;
2393   swig_callbackOnPropertySet = 0;
2394   swig_callbackOnSizeSet = 0;
2395   swig_callbackOnSizeAnimation = 0;
2396   swig_callbackOnTouchEvent = 0;
2397   swig_callbackOnHoverEvent = 0;
2398   swig_callbackOnKeyEvent = 0;
2399   swig_callbackOnWheelEvent = 0;
2400   swig_callbackOnRelayout = 0;
2401   swig_callbackOnSetResizePolicy = 0;
2402   swig_callbackGetNaturalSize = 0;
2403   swig_callbackCalculateChildSize = 0;
2404   swig_callbackGetHeightForWidth = 0;
2405   swig_callbackGetWidthForHeight = 0;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2408   swig_callbackOnCalculateRelayoutSize = 0;
2409   swig_callbackOnLayoutNegotiated = 0;
2410   swig_callbackOnInitialize = 0;
2411   swig_callbackOnStyleChange = 0;
2412   swig_callbackOnAccessibilityActivated = 0;
2413   swig_callbackOnAccessibilityPan = 0;
2414   swig_callbackOnAccessibilityTouch = 0;
2415   swig_callbackOnAccessibilityValueChange = 0;
2416   swig_callbackOnAccessibilityZoom = 0;
2417   swig_callbackOnKeyInputFocusGained = 0;
2418   swig_callbackOnKeyInputFocusLost = 0;
2419   swig_callbackGetNextKeyboardFocusableActor = 0;
2420   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2421   swig_callbackOnKeyboardEnter = 0;
2422   swig_callbackOnPinch = 0;
2423   swig_callbackOnPan = 0;
2424   swig_callbackOnTap = 0;
2425   swig_callbackOnLongPress = 0;
2426   swig_callbackSignalConnected = 0;
2427   swig_callbackSignalDisconnected = 0;
2428 }
2429
2430 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2431   swig_init_callbacks();
2432 }
2433
2434 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2435
2436 }
2437
2438
2439 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2440   unsigned int c_result = SwigValueInit< unsigned int >() ;
2441   unsigned int jresult = 0 ;
2442
2443   if (!swig_callbackGetNumberOfItems) {
2444     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2445   } else {
2446     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2447     c_result = (unsigned int)jresult;
2448   }
2449   return c_result;
2450 }
2451
2452 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2453   Dali::Actor c_result ;
2454   void * jresult = 0 ;
2455   unsigned int jitemId  ;
2456
2457   if (!swig_callbackNewItem) {
2458     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2459   } else {
2460     jitemId = itemId;
2461     jresult = (void *) swig_callbackNewItem(jitemId);
2462     if (!jresult) {
2463       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2464       return c_result;
2465     }
2466     c_result = *(Dali::Actor *)jresult;
2467   }
2468   return c_result;
2469 }
2470
2471 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2472   unsigned int jitemId  ;
2473   void * jactor  ;
2474
2475   if (!swig_callbackItemReleased) {
2476     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2477     return;
2478   } else {
2479     jitemId = itemId;
2480     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2481     swig_callbackItemReleased(jitemId, jactor);
2482   }
2483 }
2484
2485 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2486   return Dali::Toolkit::ItemFactory::GetExtension();
2487 }
2488
2489 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2490   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2491   swig_callbackNewItem = callbackNewItem;
2492   swig_callbackItemReleased = callbackItemReleased;
2493 }
2494
2495 void SwigDirector_ItemFactory::swig_init_callbacks() {
2496   swig_callbackGetNumberOfItems = 0;
2497   swig_callbackNewItem = 0;
2498   swig_callbackItemReleased = 0;
2499 }
2500
2501 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2502   swig_init_callbacks();
2503 }
2504
2505 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2506
2507 }
2508
2509
2510 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2511   Dali::Actor c_result ;
2512   void * jresult = 0 ;
2513   void * jcurrent  ;
2514   void * jproposed  ;
2515   int jdirection  ;
2516
2517   if (!swig_callbackGetNextFocusableActor) {
2518     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2519   } else {
2520     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2521     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2522     jdirection = (int)direction;
2523     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2524     if (!jresult) {
2525       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__);
2526       return c_result;
2527     }
2528     c_result = *(Dali::Actor *)jresult;
2529   }
2530   return c_result;
2531 }
2532
2533 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2534   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2535 }
2536
2537 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2538   swig_callbackGetNextFocusableActor = 0;
2539 }
2540
2541 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2542   swig_callbackOnUpdate = 0;
2543 }
2544
2545 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2546
2547 }
2548
2549 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2550   swig_callbackOnUpdate = callbackUpdate;
2551 }
2552
2553
2554 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2555   void * jcurrent  ;
2556
2557   if (!swig_callbackOnUpdate) {
2558     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2559   } else {
2560     Dali::UpdateProxy* proxy = &updateProxy;
2561     jcurrent = (void *)proxy;
2562     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2563     if (!jcurrent) {
2564       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2565       return;
2566     }
2567   }
2568   return;
2569 }
2570
2571
2572 #ifdef __cplusplus
2573 extern "C" {
2574 #endif
2575
2576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2577   void * jresult ;
2578   floatp *result = 0 ;
2579
2580   {
2581     try {
2582       result = (floatp *)new_floatp();
2583     } catch (std::out_of_range& e) {
2584       {
2585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2586       };
2587     } catch (std::exception& e) {
2588       {
2589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2590       };
2591     } catch (DaliException e) {
2592       {
2593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2594       };
2595     } catch (...) {
2596       {
2597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2598       };
2599     }
2600   }
2601   jresult = (void *)result;
2602   return jresult;
2603 }
2604
2605
2606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2607   floatp *arg1 = (floatp *) 0 ;
2608
2609   arg1 = (floatp *)jarg1;
2610   {
2611     try {
2612       delete_floatp(arg1);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2620       };
2621     } catch (Dali::DaliException e) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2624       };
2625     } catch (...) {
2626       {
2627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2628       };
2629     }
2630   }
2631
2632 }
2633
2634
2635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2636   floatp *arg1 = (floatp *) 0 ;
2637   float arg2 ;
2638
2639   arg1 = (floatp *)jarg1;
2640   arg2 = (float)jarg2;
2641   {
2642     try {
2643       floatp_assign(arg1,arg2);
2644     } catch (std::out_of_range& e) {
2645       {
2646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2647       };
2648     } catch (std::exception& e) {
2649       {
2650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2651       };
2652     } catch (Dali::DaliException e) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2655       };
2656     } catch (...) {
2657       {
2658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2659       };
2660     }
2661   }
2662
2663 }
2664
2665
2666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2667   float jresult ;
2668   floatp *arg1 = (floatp *) 0 ;
2669   float result;
2670
2671   arg1 = (floatp *)jarg1;
2672   {
2673     try {
2674       result = (float)floatp_value(arg1);
2675     } catch (std::out_of_range& e) {
2676       {
2677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2678       };
2679     } catch (std::exception& e) {
2680       {
2681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2682       };
2683     } catch (DaliException e) {
2684       {
2685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2686       };
2687     } catch (...) {
2688       {
2689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2690       };
2691     }
2692   }
2693   jresult = result;
2694   return jresult;
2695 }
2696
2697
2698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2699   void * jresult ;
2700   floatp *arg1 = (floatp *) 0 ;
2701   float *result = 0 ;
2702
2703   arg1 = (floatp *)jarg1;
2704   {
2705     try {
2706       result = (float *)floatp_cast(arg1);
2707     } catch (std::out_of_range& e) {
2708       {
2709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2710       };
2711     } catch (std::exception& e) {
2712       {
2713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2714       };
2715     } catch (Dali::DaliException e) {
2716       {
2717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2718       };
2719     } catch (...) {
2720       {
2721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2722       };
2723     }
2724   }
2725
2726   jresult = (void *)result;
2727   return jresult;
2728 }
2729
2730
2731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2732   void * jresult ;
2733   float *arg1 = (float *) 0 ;
2734   floatp *result = 0 ;
2735
2736   arg1 = (float *)jarg1;
2737   {
2738     try {
2739       result = (floatp *)floatp_frompointer(arg1);
2740     } catch (std::out_of_range& e) {
2741       {
2742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (std::exception& e) {
2745       {
2746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2747       };
2748     } catch (Dali::DaliException e) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2751       };
2752     } catch (...) {
2753       {
2754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2755       };
2756     }
2757   }
2758
2759   jresult = (void *)result;
2760   return jresult;
2761 }
2762
2763
2764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2765   void * jresult ;
2766   intp *result = 0 ;
2767
2768   {
2769     try {
2770       result = (intp *)new_intp();
2771     } catch (std::out_of_range& e) {
2772       {
2773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2774       };
2775     } catch (std::exception& e) {
2776       {
2777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2778       };
2779     } catch (Dali::DaliException e) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2782       };
2783     } catch (...) {
2784       {
2785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2786       };
2787     }
2788   }
2789
2790   jresult = (void *)result;
2791   return jresult;
2792 }
2793
2794
2795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2796   intp *arg1 = (intp *) 0 ;
2797
2798   arg1 = (intp *)jarg1;
2799   {
2800     try {
2801       delete_intp(arg1);
2802     } catch (std::out_of_range& e) {
2803       {
2804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (std::exception& e) {
2807       {
2808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2809       };
2810     } catch (Dali::DaliException e) {
2811       {
2812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2813       };
2814     } catch (...) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2817       };
2818     }
2819   }
2820
2821 }
2822
2823
2824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2825   intp *arg1 = (intp *) 0 ;
2826   int arg2 ;
2827
2828   arg1 = (intp *)jarg1;
2829   arg2 = (int)jarg2;
2830   {
2831     try {
2832       intp_assign(arg1,arg2);
2833     } catch (std::out_of_range& e) {
2834       {
2835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2836       };
2837     } catch (std::exception& e) {
2838       {
2839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2840       };
2841     } catch (Dali::DaliException e) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2844       };
2845     } catch (...) {
2846       {
2847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2848       };
2849     }
2850   }
2851
2852 }
2853
2854
2855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2856   int jresult ;
2857   intp *arg1 = (intp *) 0 ;
2858   int result;
2859
2860   arg1 = (intp *)jarg1;
2861   {
2862     try {
2863       result = (int)intp_value(arg1);
2864     } catch (std::out_of_range& e) {
2865       {
2866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2867       };
2868     } catch (std::exception& e) {
2869       {
2870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (Dali::DaliException e) {
2873       {
2874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882
2883   jresult = result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2889   void * jresult ;
2890   intp *arg1 = (intp *) 0 ;
2891   int *result = 0 ;
2892
2893   arg1 = (intp *)jarg1;
2894   {
2895     try {
2896       result = (int *)intp_cast(arg1);
2897     } catch (std::out_of_range& e) {
2898       {
2899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2900       };
2901     } catch (std::exception& e) {
2902       {
2903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2904       };
2905     } catch (Dali::DaliException e) {
2906       {
2907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2908       };
2909     } catch (...) {
2910       {
2911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2912       };
2913     }
2914   }
2915
2916   jresult = (void *)result;
2917   return jresult;
2918 }
2919
2920
2921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2922   void * jresult ;
2923   int *arg1 = (int *) 0 ;
2924   intp *result = 0 ;
2925
2926   arg1 = (int *)jarg1;
2927   {
2928     try {
2929       result = (intp *)intp_frompointer(arg1);
2930     } catch (std::out_of_range& e) {
2931       {
2932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (std::exception& e) {
2935       {
2936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2937       };
2938     } catch (Dali::DaliException e) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2941       };
2942     } catch (...) {
2943       {
2944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2945       };
2946     }
2947   }
2948
2949   jresult = (void *)result;
2950   return jresult;
2951 }
2952
2953
2954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2955   void * jresult ;
2956   doublep *result = 0 ;
2957
2958   {
2959     try {
2960       result = (doublep *)new_doublep();
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (Dali::DaliException e) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2972       };
2973     } catch (...) {
2974       {
2975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2976       };
2977     }
2978   }
2979
2980   jresult = (void *)result;
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2986   doublep *arg1 = (doublep *) 0 ;
2987
2988   arg1 = (doublep *)jarg1;
2989   {
2990     try {
2991       delete_doublep(arg1);
2992     } catch (std::out_of_range& e) {
2993       {
2994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2995       };
2996     } catch (std::exception& e) {
2997       {
2998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2999       };
3000     } catch (Dali::DaliException e) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3003       };
3004     } catch (...) {
3005       {
3006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3007       };
3008     }
3009   }
3010
3011 }
3012
3013
3014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3015   doublep *arg1 = (doublep *) 0 ;
3016   double arg2 ;
3017
3018   arg1 = (doublep *)jarg1;
3019   arg2 = (double)jarg2;
3020   {
3021     try {
3022       doublep_assign(arg1,arg2);
3023     } catch (std::out_of_range& e) {
3024       {
3025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3026       };
3027     } catch (std::exception& e) {
3028       {
3029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3030       };
3031     } catch (Dali::DaliException e) {
3032       {
3033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3034       };
3035     } catch (...) {
3036       {
3037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3038       };
3039     }
3040   }
3041
3042 }
3043
3044
3045 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3046   double jresult ;
3047   doublep *arg1 = (doublep *) 0 ;
3048   double result;
3049
3050   arg1 = (doublep *)jarg1;
3051   {
3052     try {
3053       result = (double)doublep_value(arg1);
3054     } catch (std::out_of_range& e) {
3055       {
3056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3057       };
3058     } catch (std::exception& e) {
3059       {
3060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3061       };
3062     } catch (Dali::DaliException e) {
3063       {
3064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3065       };
3066     } catch (...) {
3067       {
3068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3069       };
3070     }
3071   }
3072
3073   jresult = result;
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3079   void * jresult ;
3080   doublep *arg1 = (doublep *) 0 ;
3081   double *result = 0 ;
3082
3083   arg1 = (doublep *)jarg1;
3084   {
3085     try {
3086       result = (double *)doublep_cast(arg1);
3087     } catch (std::out_of_range& e) {
3088       {
3089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3090       };
3091     } catch (std::exception& e) {
3092       {
3093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3094       };
3095     } catch (Dali::DaliException e) {
3096       {
3097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3098       };
3099     } catch (...) {
3100       {
3101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3102       };
3103     }
3104   }
3105
3106   jresult = (void *)result;
3107   return jresult;
3108 }
3109
3110
3111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3112   void * jresult ;
3113   double *arg1 = (double *) 0 ;
3114   doublep *result = 0 ;
3115
3116   arg1 = (double *)jarg1;
3117   {
3118     try {
3119       result = (doublep *)doublep_frompointer(arg1);
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (Dali::DaliException e) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3131       };
3132     } catch (...) {
3133       {
3134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3135       };
3136     }
3137   }
3138
3139   jresult = (void *)result;
3140   return jresult;
3141 }
3142
3143
3144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3145   void * jresult ;
3146   uintp *result = 0 ;
3147
3148   {
3149     try {
3150       result = (uintp *)new_uintp();
3151     } catch (std::out_of_range& e) {
3152       {
3153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3154       };
3155     } catch (std::exception& e) {
3156       {
3157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3158       };
3159     } catch (Dali::DaliException e) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3162       };
3163     } catch (...) {
3164       {
3165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3166       };
3167     }
3168   }
3169
3170   jresult = (void *)result;
3171   return jresult;
3172 }
3173
3174
3175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3176   uintp *arg1 = (uintp *) 0 ;
3177
3178   arg1 = (uintp *)jarg1;
3179   {
3180     try {
3181       delete_uintp(arg1);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3189       };
3190     } catch (Dali::DaliException e) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3193       };
3194     } catch (...) {
3195       {
3196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3197       };
3198     }
3199   }
3200
3201 }
3202
3203
3204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3205   uintp *arg1 = (uintp *) 0 ;
3206   unsigned int arg2 ;
3207
3208   arg1 = (uintp *)jarg1;
3209   arg2 = (unsigned int)jarg2;
3210   {
3211     try {
3212       uintp_assign(arg1,arg2);
3213     } catch (std::out_of_range& e) {
3214       {
3215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3216       };
3217     } catch (std::exception& e) {
3218       {
3219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3220       };
3221     } catch (Dali::DaliException e) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3224       };
3225     } catch (...) {
3226       {
3227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3228       };
3229     }
3230   }
3231
3232 }
3233
3234
3235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3236   unsigned int jresult ;
3237   uintp *arg1 = (uintp *) 0 ;
3238   unsigned int result;
3239
3240   arg1 = (uintp *)jarg1;
3241   {
3242     try {
3243       result = (unsigned int)uintp_value(arg1);
3244     } catch (std::out_of_range& e) {
3245       {
3246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (std::exception& e) {
3249       {
3250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3251       };
3252     } catch (Dali::DaliException e) {
3253       {
3254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3255       };
3256     } catch (...) {
3257       {
3258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3259       };
3260     }
3261   }
3262
3263   jresult = result;
3264   return jresult;
3265 }
3266
3267
3268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3269   void * jresult ;
3270   uintp *arg1 = (uintp *) 0 ;
3271   unsigned int *result = 0 ;
3272
3273   arg1 = (uintp *)jarg1;
3274   {
3275     try {
3276       result = (unsigned int *)uintp_cast(arg1);
3277     } catch (std::out_of_range& e) {
3278       {
3279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3280       };
3281     } catch (std::exception& e) {
3282       {
3283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3284       };
3285     } catch (Dali::DaliException e) {
3286       {
3287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3288       };
3289     } catch (...) {
3290       {
3291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3292       };
3293     }
3294   }
3295
3296   jresult = (void *)result;
3297   return jresult;
3298 }
3299
3300
3301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3302   void * jresult ;
3303   unsigned int *arg1 = (unsigned int *) 0 ;
3304   uintp *result = 0 ;
3305
3306   arg1 = (unsigned int *)jarg1;
3307   {
3308     try {
3309       result = (uintp *)uintp_frompointer(arg1);
3310     } catch (std::out_of_range& e) {
3311       {
3312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (std::exception& e) {
3315       {
3316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3317       };
3318     } catch (Dali::DaliException e) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3321       };
3322     } catch (...) {
3323       {
3324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3325       };
3326     }
3327   }
3328
3329   jresult = (void *)result;
3330   return jresult;
3331 }
3332
3333
3334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3335   void * jresult ;
3336   ushortp *result = 0 ;
3337
3338   {
3339     try {
3340       result = (ushortp *)new_ushortp();
3341     } catch (std::out_of_range& e) {
3342       {
3343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3344       };
3345     } catch (std::exception& e) {
3346       {
3347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3348       };
3349     } catch (Dali::DaliException e) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3352       };
3353     } catch (...) {
3354       {
3355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3356       };
3357     }
3358   }
3359
3360   jresult = (void *)result;
3361   return jresult;
3362 }
3363
3364
3365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3366   ushortp *arg1 = (ushortp *) 0 ;
3367
3368   arg1 = (ushortp *)jarg1;
3369   {
3370     try {
3371       delete_ushortp(arg1);
3372     } catch (std::out_of_range& e) {
3373       {
3374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3375       };
3376     } catch (std::exception& e) {
3377       {
3378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3379       };
3380     } catch (Dali::DaliException e) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3383       };
3384     } catch (...) {
3385       {
3386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3387       };
3388     }
3389   }
3390
3391 }
3392
3393
3394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3395   ushortp *arg1 = (ushortp *) 0 ;
3396   unsigned short arg2 ;
3397
3398   arg1 = (ushortp *)jarg1;
3399   arg2 = (unsigned short)jarg2;
3400   {
3401     try {
3402       ushortp_assign(arg1,arg2);
3403     } catch (std::out_of_range& e) {
3404       {
3405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3406       };
3407     } catch (std::exception& e) {
3408       {
3409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3410       };
3411     } catch (Dali::DaliException e) {
3412       {
3413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3414       };
3415     } catch (...) {
3416       {
3417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3418       };
3419     }
3420   }
3421
3422 }
3423
3424
3425 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3426   unsigned short jresult ;
3427   ushortp *arg1 = (ushortp *) 0 ;
3428   unsigned short result;
3429
3430   arg1 = (ushortp *)jarg1;
3431   {
3432     try {
3433       result = (unsigned short)ushortp_value(arg1);
3434     } catch (std::out_of_range& e) {
3435       {
3436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3437       };
3438     } catch (std::exception& e) {
3439       {
3440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3441       };
3442     } catch (Dali::DaliException e) {
3443       {
3444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3445       };
3446     } catch (...) {
3447       {
3448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3449       };
3450     }
3451   }
3452
3453   jresult = result;
3454   return jresult;
3455 }
3456
3457
3458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3459   void * jresult ;
3460   ushortp *arg1 = (ushortp *) 0 ;
3461   unsigned short *result = 0 ;
3462
3463   arg1 = (ushortp *)jarg1;
3464   {
3465     try {
3466       result = (unsigned short *)ushortp_cast(arg1);
3467     } catch (std::out_of_range& e) {
3468       {
3469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3470       };
3471     } catch (std::exception& e) {
3472       {
3473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3474       };
3475     } catch (Dali::DaliException e) {
3476       {
3477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3478       };
3479     } catch (...) {
3480       {
3481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3482       };
3483     }
3484   }
3485
3486   jresult = (void *)result;
3487   return jresult;
3488 }
3489
3490
3491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3492   void * jresult ;
3493   unsigned short *arg1 = (unsigned short *) 0 ;
3494   ushortp *result = 0 ;
3495
3496   arg1 = (unsigned short *)jarg1;
3497   {
3498     try {
3499       result = (ushortp *)ushortp_frompointer(arg1);
3500     } catch (std::out_of_range& e) {
3501       {
3502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3503       };
3504     } catch (std::exception& e) {
3505       {
3506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3507       };
3508     } catch (Dali::DaliException e) {
3509       {
3510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3511       };
3512     } catch (...) {
3513       {
3514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3515       };
3516     }
3517   }
3518
3519   jresult = (void *)result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3525   unsigned int jresult ;
3526   int arg1 ;
3527   unsigned int result;
3528
3529   arg1 = (int)jarg1;
3530   {
3531     try {
3532       result = (unsigned int)int_to_uint(arg1);
3533     } catch (std::out_of_range& e) {
3534       {
3535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3536       };
3537     } catch (std::exception& e) {
3538       {
3539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3540       };
3541     } catch (Dali::DaliException e) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3544       };
3545     } catch (...) {
3546       {
3547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3548       };
3549     }
3550   }
3551
3552   jresult = result;
3553   return jresult;
3554 }
3555
3556
3557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3558   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3559
3560   arg1 = (Dali::RefObject *)jarg1;
3561   {
3562     try {
3563       (arg1)->Reference();
3564     } catch (std::out_of_range& e) {
3565       {
3566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3567       };
3568     } catch (std::exception& e) {
3569       {
3570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3571       };
3572     } catch (Dali::DaliException e) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3575       };
3576     } catch (...) {
3577       {
3578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3579       };
3580     }
3581   }
3582
3583 }
3584
3585
3586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3587   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3588
3589   arg1 = (Dali::RefObject *)jarg1;
3590   {
3591     try {
3592       (arg1)->Unreference();
3593     } catch (std::out_of_range& e) {
3594       {
3595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3596       };
3597     } catch (std::exception& e) {
3598       {
3599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3600       };
3601     } catch (Dali::DaliException e) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3604       };
3605     } catch (...) {
3606       {
3607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3608       };
3609     }
3610   }
3611
3612 }
3613
3614
3615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3616   int jresult ;
3617   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3618   int result;
3619
3620   arg1 = (Dali::RefObject *)jarg1;
3621   {
3622     try {
3623       result = (int)(arg1)->ReferenceCount();
3624     } catch (std::out_of_range& e) {
3625       {
3626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (std::exception& e) {
3629       {
3630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3631       };
3632     } catch (Dali::DaliException e) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3639       };
3640     }
3641   }
3642
3643   jresult = result;
3644   return jresult;
3645 }
3646
3647
3648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3649   void * jresult ;
3650   Dali::Any *result = 0 ;
3651
3652   {
3653     try {
3654       result = (Dali::Any *)new Dali::Any();
3655     } catch (std::out_of_range& e) {
3656       {
3657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3658       };
3659     } catch (std::exception& e) {
3660       {
3661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3662       };
3663     } catch (Dali::DaliException e) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3666       };
3667     } catch (...) {
3668       {
3669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3670       };
3671     }
3672   }
3673
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3680   Dali::Any *arg1 = (Dali::Any *) 0 ;
3681
3682   arg1 = (Dali::Any *)jarg1;
3683   {
3684     try {
3685       delete arg1;
3686     } catch (std::out_of_range& e) {
3687       {
3688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3689       };
3690     } catch (std::exception& e) {
3691       {
3692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3693       };
3694     } catch (Dali::DaliException e) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3697       };
3698     } catch (...) {
3699       {
3700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3701       };
3702     }
3703   }
3704
3705 }
3706
3707
3708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3709   char *arg1 = (char *) 0 ;
3710
3711   arg1 = (char *)jarg1;
3712   {
3713     try {
3714       Dali::Any::AssertAlways((char const *)arg1);
3715     } catch (std::out_of_range& e) {
3716       {
3717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3718       };
3719     } catch (std::exception& e) {
3720       {
3721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3722       };
3723     } catch (Dali::DaliException e) {
3724       {
3725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3726       };
3727     } catch (...) {
3728       {
3729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3730       };
3731     }
3732   }
3733
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3738   void * jresult ;
3739   Dali::Any *arg1 = 0 ;
3740   Dali::Any *result = 0 ;
3741
3742   arg1 = (Dali::Any *)jarg1;
3743   if (!arg1) {
3744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3745     return 0;
3746   }
3747   {
3748     try {
3749       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3750     } catch (std::out_of_range& e) {
3751       {
3752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3753       };
3754     } catch (std::exception& e) {
3755       {
3756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3757       };
3758     } catch (Dali::DaliException e) {
3759       {
3760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3761       };
3762     } catch (...) {
3763       {
3764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3765       };
3766     }
3767   }
3768
3769   jresult = (void *)result;
3770   return jresult;
3771 }
3772
3773
3774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3775   void * jresult ;
3776   Dali::Any *arg1 = (Dali::Any *) 0 ;
3777   Dali::Any *arg2 = 0 ;
3778   Dali::Any *result = 0 ;
3779
3780   arg1 = (Dali::Any *)jarg1;
3781   arg2 = (Dali::Any *)jarg2;
3782   if (!arg2) {
3783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3784     return 0;
3785   }
3786   {
3787     try {
3788       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3789     } catch (std::out_of_range& e) {
3790       {
3791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3792       };
3793     } catch (std::exception& e) {
3794       {
3795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3796       };
3797     } catch (Dali::DaliException e) {
3798       {
3799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3800       };
3801     } catch (...) {
3802       {
3803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3804       };
3805     }
3806   }
3807
3808   jresult = (void *)result;
3809   return jresult;
3810 }
3811
3812
3813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3814   void * jresult ;
3815   Dali::Any *arg1 = (Dali::Any *) 0 ;
3816   std::type_info *result = 0 ;
3817
3818   arg1 = (Dali::Any *)jarg1;
3819   {
3820     try {
3821       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3822     } catch (std::out_of_range& e) {
3823       {
3824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3825       };
3826     } catch (std::exception& e) {
3827       {
3828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3829       };
3830     } catch (Dali::DaliException e) {
3831       {
3832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3833       };
3834     } catch (...) {
3835       {
3836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3837       };
3838     }
3839   }
3840
3841   jresult = (void *)result;
3842   return jresult;
3843 }
3844
3845
3846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3847   unsigned int jresult ;
3848   Dali::Any *arg1 = (Dali::Any *) 0 ;
3849   bool result;
3850
3851   arg1 = (Dali::Any *)jarg1;
3852   {
3853     try {
3854       result = (bool)((Dali::Any const *)arg1)->Empty();
3855     } catch (std::out_of_range& e) {
3856       {
3857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3858       };
3859     } catch (std::exception& e) {
3860       {
3861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3862       };
3863     } catch (Dali::DaliException e) {
3864       {
3865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3866       };
3867     } catch (...) {
3868       {
3869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3870       };
3871     }
3872   }
3873
3874   jresult = result;
3875   return jresult;
3876 }
3877
3878
3879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3880   void * jresult ;
3881   std::type_info *arg1 = 0 ;
3882   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3883   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3884   Dali::Any::AnyContainerBase *result = 0 ;
3885
3886   arg1 = (std::type_info *)jarg1;
3887   if (!arg1) {
3888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3889     return 0;
3890   }
3891   arg2 = (Dali::Any::CloneFunc)jarg2;
3892   arg3 = (Dali::Any::DeleteFunc)jarg3;
3893   {
3894     try {
3895       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3896     } catch (std::out_of_range& e) {
3897       {
3898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3899       };
3900     } catch (std::exception& e) {
3901       {
3902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3903       };
3904     } catch (Dali::DaliException e) {
3905       {
3906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3907       };
3908     } catch (...) {
3909       {
3910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3911       };
3912     }
3913   }
3914
3915   jresult = (void *)result;
3916   return jresult;
3917 }
3918
3919
3920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3921   void * jresult ;
3922   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3923   std::type_info *result = 0 ;
3924
3925   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3926   {
3927     try {
3928       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3929     } catch (std::out_of_range& e) {
3930       {
3931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3932       };
3933     } catch (std::exception& e) {
3934       {
3935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3936       };
3937     } catch (Dali::DaliException e) {
3938       {
3939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3940       };
3941     } catch (...) {
3942       {
3943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3944       };
3945     }
3946   }
3947
3948   jresult = (void *)result;
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3954   void * jresult ;
3955   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3956   ::std::type_info *result = 0 ;
3957
3958   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3959   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3960   jresult = (void *)result;
3961   return jresult;
3962 }
3963
3964
3965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   arg2 = (Dali::Any::CloneFunc)jarg2;
3971   if (arg1) (arg1)->mCloneFunc = arg2;
3972 }
3973
3974
3975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3976   void * jresult ;
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978   Dali::Any::CloneFunc result;
3979
3980   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3981   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3982   jresult = (void *)result;
3983   return jresult;
3984 }
3985
3986
3987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3988   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3989   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3990
3991   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3992   arg2 = (Dali::Any::DeleteFunc)jarg2;
3993   if (arg1) (arg1)->mDeleteFunc = arg2;
3994 }
3995
3996
3997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3998   void * jresult ;
3999   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4000   Dali::Any::DeleteFunc result;
4001
4002   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4003   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4004   jresult = (void *)result;
4005   return jresult;
4006 }
4007
4008
4009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4010   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4011
4012   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4013   {
4014     try {
4015       delete arg1;
4016     } catch (std::out_of_range& e) {
4017       {
4018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4019       };
4020     } catch (std::exception& e) {
4021       {
4022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4023       };
4024     } catch (Dali::DaliException e) {
4025       {
4026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4027       };
4028     } catch (...) {
4029       {
4030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4031       };
4032     }
4033   }
4034
4035 }
4036
4037
4038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4039   Dali::Any *arg1 = (Dali::Any *) 0 ;
4040   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4041
4042   arg1 = (Dali::Any *)jarg1;
4043   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4044   if (arg1) (arg1)->mContainer = arg2;
4045 }
4046
4047
4048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4049   void * jresult ;
4050   Dali::Any *arg1 = (Dali::Any *) 0 ;
4051   Dali::Any::AnyContainerBase *result = 0 ;
4052
4053   arg1 = (Dali::Any *)jarg1;
4054   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4055   jresult = (void *)result;
4056   return jresult;
4057 }
4058
4059
4060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4061   char *arg1 = (char *) 0 ;
4062   char *arg2 = (char *) 0 ;
4063
4064   arg1 = (char *)jarg1;
4065   arg2 = (char *)jarg2;
4066   {
4067     try {
4068       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4069     } catch (std::out_of_range& e) {
4070       {
4071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4072       };
4073     } catch (std::exception& e) {
4074       {
4075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4076       };
4077     } catch (Dali::DaliException e) {
4078       {
4079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4080       };
4081     } catch (...) {
4082       {
4083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4084       };
4085     }
4086   }
4087
4088 }
4089
4090
4091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4092   void * jresult ;
4093   char *arg1 = (char *) 0 ;
4094   char *arg2 = (char *) 0 ;
4095   Dali::DaliException *result = 0 ;
4096
4097   arg1 = (char *)jarg1;
4098   arg2 = (char *)jarg2;
4099   {
4100     try {
4101       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4102     } catch (std::out_of_range& e) {
4103       {
4104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4105       };
4106     } catch (std::exception& e) {
4107       {
4108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4109       };
4110     } catch (Dali::DaliException e) {
4111       {
4112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4113       };
4114     } catch (...) {
4115       {
4116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4117       };
4118     }
4119   }
4120
4121   jresult = (void *)result;
4122   return jresult;
4123 }
4124
4125
4126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4127   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4128   std::string arg2 = std::string(jarg2);
4129
4130   arg1 = (Dali::DaliException *)jarg1;
4131   {
4132     if (!arg2.empty()) {
4133       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4134     } else {
4135       arg1->location = 0;
4136     }
4137   }
4138 }
4139
4140 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4141   char * jresult ;
4142   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4143   char *result = 0 ;
4144
4145   arg1 = (Dali::DaliException *)jarg1;
4146   result = (char *) ((arg1)->location);
4147   jresult = SWIG_csharp_string_callback((const char *)result);
4148   return jresult;
4149 }
4150
4151
4152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4153   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4154   std::string arg2 = std::string(jarg2);
4155
4156   arg1 = (Dali::DaliException *)jarg1;
4157   {
4158     if (!arg2.empty()) {
4159       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4160     } else {
4161       arg1->condition = 0;
4162     }
4163   }
4164 }
4165
4166
4167 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4168   char * jresult ;
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   char *result = 0 ;
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   result = (char *) ((arg1)->condition);
4174   jresult = SWIG_csharp_string_callback((const char *)result);
4175   return jresult;
4176 }
4177
4178
4179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4180   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4181
4182   arg1 = (Dali::DaliException *)jarg1;
4183   {
4184     try {
4185       delete arg1;
4186     } catch (std::out_of_range& e) {
4187       {
4188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4189       };
4190     } catch (std::exception& e) {
4191       {
4192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4193       };
4194     } catch (Dali::DaliException e) {
4195       {
4196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4197       };
4198     } catch (...) {
4199       {
4200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4201       };
4202     }
4203   }
4204
4205 }
4206
4207
4208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4209   void * jresult ;
4210   Dali::Vector2 *result = 0 ;
4211
4212   {
4213     try {
4214       result = (Dali::Vector2 *)new Dali::Vector2();
4215     } catch (std::out_of_range& e) {
4216       {
4217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4218       };
4219     } catch (std::exception& e) {
4220       {
4221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4222       };
4223     } catch (Dali::DaliException e) {
4224       {
4225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4226       };
4227     } catch (...) {
4228       {
4229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4230       };
4231     }
4232   }
4233
4234   jresult = (void *)result;
4235   return jresult;
4236 }
4237
4238
4239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4240   void * jresult ;
4241   float arg1 ;
4242   float arg2 ;
4243   Dali::Vector2 *result = 0 ;
4244
4245   arg1 = (float)jarg1;
4246   arg2 = (float)jarg2;
4247   {
4248     try {
4249       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4250     } catch (std::out_of_range& e) {
4251       {
4252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4253       };
4254     } catch (std::exception& e) {
4255       {
4256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4257       };
4258     } catch (Dali::DaliException e) {
4259       {
4260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4261       };
4262     } catch (...) {
4263       {
4264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4265       };
4266     }
4267   }
4268
4269   jresult = (void *)result;
4270   return jresult;
4271 }
4272
4273
4274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4275   void * jresult ;
4276   float *arg1 = (float *) 0 ;
4277   Dali::Vector2 *result = 0 ;
4278
4279   arg1 = jarg1;
4280   {
4281     try {
4282       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4283     } catch (std::out_of_range& e) {
4284       {
4285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4286       };
4287     } catch (std::exception& e) {
4288       {
4289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4290       };
4291     } catch (Dali::DaliException e) {
4292       {
4293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4294       };
4295     } catch (...) {
4296       {
4297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4298       };
4299     }
4300   }
4301
4302   jresult = (void *)result;
4303
4304
4305   return jresult;
4306 }
4307
4308
4309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4310   void * jresult ;
4311   Dali::Vector3 *arg1 = 0 ;
4312   Dali::Vector2 *result = 0 ;
4313
4314   arg1 = (Dali::Vector3 *)jarg1;
4315   if (!arg1) {
4316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4317     return 0;
4318   }
4319   {
4320     try {
4321       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4322     } catch (std::out_of_range& e) {
4323       {
4324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4325       };
4326     } catch (std::exception& e) {
4327       {
4328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4329       };
4330     } catch (Dali::DaliException e) {
4331       {
4332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4333       };
4334     } catch (...) {
4335       {
4336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4337       };
4338     }
4339   }
4340
4341   jresult = (void *)result;
4342   return jresult;
4343 }
4344
4345
4346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4347   void * jresult ;
4348   Dali::Vector4 *arg1 = 0 ;
4349   Dali::Vector2 *result = 0 ;
4350
4351   arg1 = (Dali::Vector4 *)jarg1;
4352   if (!arg1) {
4353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4354     return 0;
4355   }
4356   {
4357     try {
4358       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4359     } catch (std::out_of_range& e) {
4360       {
4361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4362       };
4363     } catch (std::exception& e) {
4364       {
4365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4366       };
4367     } catch (Dali::DaliException e) {
4368       {
4369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4370       };
4371     } catch (...) {
4372       {
4373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4374       };
4375     }
4376   }
4377
4378   jresult = (void *)result;
4379   return jresult;
4380 }
4381
4382
4383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4384   void * jresult ;
4385   Dali::Vector2 *result = 0 ;
4386
4387   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4394   void * jresult ;
4395   Dali::Vector2 *result = 0 ;
4396
4397   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4398   jresult = (void *)result;
4399   return jresult;
4400 }
4401
4402
4403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4404   void * jresult ;
4405   Dali::Vector2 *result = 0 ;
4406
4407   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4408   jresult = (void *)result;
4409   return jresult;
4410 }
4411
4412
4413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4414   void * jresult ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4418   jresult = (void *)result;
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4424   void * jresult ;
4425   Dali::Vector2 *result = 0 ;
4426
4427   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4428   jresult = (void *)result;
4429   return jresult;
4430 }
4431
4432
4433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4434   void * jresult ;
4435   Dali::Vector2 *result = 0 ;
4436
4437   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4438   jresult = (void *)result;
4439   return jresult;
4440 }
4441
4442
4443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4444   void * jresult ;
4445   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4446   float *arg2 = (float *) 0 ;
4447   Dali::Vector2 *result = 0 ;
4448
4449   arg1 = (Dali::Vector2 *)jarg1;
4450   arg2 = jarg2;
4451   {
4452     try {
4453       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4454     } catch (std::out_of_range& e) {
4455       {
4456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4457       };
4458     } catch (std::exception& e) {
4459       {
4460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4461       };
4462     } catch (Dali::DaliException e) {
4463       {
4464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4465       };
4466     } catch (...) {
4467       {
4468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4469       };
4470     }
4471   }
4472
4473   jresult = (void *)result;
4474
4475
4476   return jresult;
4477 }
4478
4479
4480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4481   void * jresult ;
4482   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4483   Dali::Vector3 *arg2 = 0 ;
4484   Dali::Vector2 *result = 0 ;
4485
4486   arg1 = (Dali::Vector2 *)jarg1;
4487   arg2 = (Dali::Vector3 *)jarg2;
4488   if (!arg2) {
4489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4490     return 0;
4491   }
4492   {
4493     try {
4494       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4495     } catch (std::out_of_range& e) {
4496       {
4497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4498       };
4499     } catch (std::exception& e) {
4500       {
4501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4502       };
4503     } catch (Dali::DaliException e) {
4504       {
4505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4506       };
4507     } catch (...) {
4508       {
4509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4510       };
4511     }
4512   }
4513
4514   jresult = (void *)result;
4515   return jresult;
4516 }
4517
4518
4519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4520   void * jresult ;
4521   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4522   Dali::Vector4 *arg2 = 0 ;
4523   Dali::Vector2 *result = 0 ;
4524
4525   arg1 = (Dali::Vector2 *)jarg1;
4526   arg2 = (Dali::Vector4 *)jarg2;
4527   if (!arg2) {
4528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4529     return 0;
4530   }
4531   {
4532     try {
4533       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4534     } catch (std::out_of_range& e) {
4535       {
4536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4537       };
4538     } catch (std::exception& e) {
4539       {
4540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4541       };
4542     } catch (Dali::DaliException e) {
4543       {
4544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4545       };
4546     } catch (...) {
4547       {
4548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4549       };
4550     }
4551   }
4552
4553   jresult = (void *)result;
4554   return jresult;
4555 }
4556
4557
4558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4559   void * jresult ;
4560   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4561   Dali::Vector2 *arg2 = 0 ;
4562   Dali::Vector2 result;
4563
4564   arg1 = (Dali::Vector2 *)jarg1;
4565   arg2 = (Dali::Vector2 *)jarg2;
4566   if (!arg2) {
4567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4568     return 0;
4569   }
4570   {
4571     try {
4572       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4573     } catch (std::out_of_range& e) {
4574       {
4575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4576       };
4577     } catch (std::exception& e) {
4578       {
4579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4580       };
4581     } catch (Dali::DaliException e) {
4582       {
4583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4584       };
4585     } catch (...) {
4586       {
4587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4588       };
4589     }
4590   }
4591
4592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4593   return jresult;
4594 }
4595
4596
4597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4598   void * jresult ;
4599   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4600   Dali::Vector2 *arg2 = 0 ;
4601   Dali::Vector2 *result = 0 ;
4602
4603   arg1 = (Dali::Vector2 *)jarg1;
4604   arg2 = (Dali::Vector2 *)jarg2;
4605   if (!arg2) {
4606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4607     return 0;
4608   }
4609   {
4610     try {
4611       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4612     } catch (std::out_of_range& e) {
4613       {
4614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (std::exception& e) {
4617       {
4618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (Dali::DaliException e) {
4621       {
4622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4623       };
4624     } catch (...) {
4625       {
4626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4627       };
4628     }
4629   }
4630
4631   jresult = (void *)result;
4632   return jresult;
4633 }
4634
4635
4636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4637   void * jresult ;
4638   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4639   Dali::Vector2 *arg2 = 0 ;
4640   Dali::Vector2 result;
4641
4642   arg1 = (Dali::Vector2 *)jarg1;
4643   arg2 = (Dali::Vector2 *)jarg2;
4644   if (!arg2) {
4645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4646     return 0;
4647   }
4648   {
4649     try {
4650       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4651     } catch (std::out_of_range& e) {
4652       {
4653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4654       };
4655     } catch (std::exception& e) {
4656       {
4657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4658       };
4659     } catch (Dali::DaliException e) {
4660       {
4661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4662       };
4663     } catch (...) {
4664       {
4665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4666       };
4667     }
4668   }
4669
4670   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4671   return jresult;
4672 }
4673
4674
4675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4676   void * jresult ;
4677   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4678   Dali::Vector2 *arg2 = 0 ;
4679   Dali::Vector2 *result = 0 ;
4680
4681   arg1 = (Dali::Vector2 *)jarg1;
4682   arg2 = (Dali::Vector2 *)jarg2;
4683   if (!arg2) {
4684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4685     return 0;
4686   }
4687   {
4688     try {
4689       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4690     } catch (std::out_of_range& e) {
4691       {
4692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4693       };
4694     } catch (std::exception& e) {
4695       {
4696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4697       };
4698     } catch (Dali::DaliException e) {
4699       {
4700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4701       };
4702     } catch (...) {
4703       {
4704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4705       };
4706     }
4707   }
4708
4709   jresult = (void *)result;
4710   return jresult;
4711 }
4712
4713
4714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4715   void * jresult ;
4716   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4717   Dali::Vector2 *arg2 = 0 ;
4718   Dali::Vector2 result;
4719
4720   arg1 = (Dali::Vector2 *)jarg1;
4721   arg2 = (Dali::Vector2 *)jarg2;
4722   if (!arg2) {
4723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4724     return 0;
4725   }
4726   {
4727     try {
4728       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4729     } catch (std::out_of_range& e) {
4730       {
4731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (std::exception& e) {
4734       {
4735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (Dali::DaliException e) {
4738       {
4739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4740       };
4741     } catch (...) {
4742       {
4743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4744       };
4745     }
4746   }
4747
4748   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4749   return jresult;
4750 }
4751
4752
4753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4754   void * jresult ;
4755   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4756   float arg2 ;
4757   Dali::Vector2 result;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   arg2 = (float)jarg2;
4761   {
4762     try {
4763       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4764     } catch (std::out_of_range& e) {
4765       {
4766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4767       };
4768     } catch (std::exception& e) {
4769       {
4770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4771       };
4772     } catch (Dali::DaliException e) {
4773       {
4774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4775       };
4776     } catch (...) {
4777       {
4778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4779       };
4780     }
4781   }
4782
4783   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4784   return jresult;
4785 }
4786
4787
4788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4789   void * jresult ;
4790   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4791   Dali::Vector2 *arg2 = 0 ;
4792   Dali::Vector2 *result = 0 ;
4793
4794   arg1 = (Dali::Vector2 *)jarg1;
4795   arg2 = (Dali::Vector2 *)jarg2;
4796   if (!arg2) {
4797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4798     return 0;
4799   }
4800   {
4801     try {
4802       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4803     } catch (std::out_of_range& e) {
4804       {
4805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4806       };
4807     } catch (std::exception& e) {
4808       {
4809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4810       };
4811     } catch (Dali::DaliException e) {
4812       {
4813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4814       };
4815     } catch (...) {
4816       {
4817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4818       };
4819     }
4820   }
4821
4822   jresult = (void *)result;
4823   return jresult;
4824 }
4825
4826
4827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4828   void * jresult ;
4829   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4830   float arg2 ;
4831   Dali::Vector2 *result = 0 ;
4832
4833   arg1 = (Dali::Vector2 *)jarg1;
4834   arg2 = (float)jarg2;
4835   {
4836     try {
4837       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4838     } catch (std::out_of_range& e) {
4839       {
4840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4841       };
4842     } catch (std::exception& e) {
4843       {
4844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4845       };
4846     } catch (Dali::DaliException e) {
4847       {
4848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4849       };
4850     } catch (...) {
4851       {
4852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4853       };
4854     }
4855   }
4856
4857   jresult = (void *)result;
4858   return jresult;
4859 }
4860
4861
4862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4863   void * jresult ;
4864   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4865   Dali::Vector2 *arg2 = 0 ;
4866   Dali::Vector2 result;
4867
4868   arg1 = (Dali::Vector2 *)jarg1;
4869   arg2 = (Dali::Vector2 *)jarg2;
4870   if (!arg2) {
4871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4872     return 0;
4873   }
4874   {
4875     try {
4876       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4877     } catch (std::out_of_range& e) {
4878       {
4879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4880       };
4881     } catch (std::exception& e) {
4882       {
4883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4884       };
4885     } catch (Dali::DaliException e) {
4886       {
4887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4888       };
4889     } catch (...) {
4890       {
4891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4892       };
4893     }
4894   }
4895
4896   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4897   return jresult;
4898 }
4899
4900
4901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4902   void * jresult ;
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   float arg2 ;
4905   Dali::Vector2 result;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (float)jarg2;
4909   {
4910     try {
4911       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4912     } catch (std::out_of_range& e) {
4913       {
4914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4915       };
4916     } catch (std::exception& e) {
4917       {
4918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4919       };
4920     } catch (Dali::DaliException e) {
4921       {
4922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4923       };
4924     } catch (...) {
4925       {
4926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4927       };
4928     }
4929   }
4930
4931   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4932   return jresult;
4933 }
4934
4935
4936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4937   void * jresult ;
4938   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4939   Dali::Vector2 *arg2 = 0 ;
4940   Dali::Vector2 *result = 0 ;
4941
4942   arg1 = (Dali::Vector2 *)jarg1;
4943   arg2 = (Dali::Vector2 *)jarg2;
4944   if (!arg2) {
4945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4946     return 0;
4947   }
4948   {
4949     try {
4950       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4951     } catch (std::out_of_range& e) {
4952       {
4953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4954       };
4955     } catch (std::exception& e) {
4956       {
4957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4958       };
4959     } catch (Dali::DaliException e) {
4960       {
4961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4962       };
4963     } catch (...) {
4964       {
4965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4966       };
4967     }
4968   }
4969
4970   jresult = (void *)result;
4971   return jresult;
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4976   void * jresult ;
4977   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4978   float arg2 ;
4979   Dali::Vector2 *result = 0 ;
4980
4981   arg1 = (Dali::Vector2 *)jarg1;
4982   arg2 = (float)jarg2;
4983   {
4984     try {
4985       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4986     } catch (std::out_of_range& e) {
4987       {
4988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4989       };
4990     } catch (std::exception& e) {
4991       {
4992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (Dali::DaliException e) {
4995       {
4996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004
5005   jresult = (void *)result;
5006   return jresult;
5007 }
5008
5009
5010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5011   void * jresult ;
5012   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5013   Dali::Vector2 result;
5014
5015   arg1 = (Dali::Vector2 *)jarg1;
5016   {
5017     try {
5018       result = ((Dali::Vector2 const *)arg1)->operator -();
5019     } catch (std::out_of_range& e) {
5020       {
5021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5022       };
5023     } catch (std::exception& e) {
5024       {
5025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5026       };
5027     } catch (Dali::DaliException e) {
5028       {
5029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5030       };
5031     } catch (...) {
5032       {
5033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5034       };
5035     }
5036   }
5037
5038   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5039   return jresult;
5040 }
5041
5042
5043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5044   unsigned int jresult ;
5045   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5046   Dali::Vector2 *arg2 = 0 ;
5047   bool result;
5048
5049   arg1 = (Dali::Vector2 *)jarg1;
5050   arg2 = (Dali::Vector2 *)jarg2;
5051   if (!arg2) {
5052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5053     return 0;
5054   }
5055   {
5056     try {
5057       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5058     } catch (std::out_of_range& e) {
5059       {
5060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5061       };
5062     } catch (std::exception& e) {
5063       {
5064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5065       };
5066     } catch (Dali::DaliException e) {
5067       {
5068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5069       };
5070     } catch (...) {
5071       {
5072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5073       };
5074     }
5075   }
5076
5077   jresult = result;
5078   return jresult;
5079 }
5080
5081
5082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5083   unsigned int jresult ;
5084   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5085   Dali::Vector2 *arg2 = 0 ;
5086   bool result;
5087
5088   arg1 = (Dali::Vector2 *)jarg1;
5089   arg2 = (Dali::Vector2 *)jarg2;
5090   if (!arg2) {
5091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5092     return 0;
5093   }
5094   {
5095     try {
5096       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5097     } catch (std::out_of_range& e) {
5098       {
5099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5100       };
5101     } catch (std::exception& e) {
5102       {
5103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5104       };
5105     } catch (Dali::DaliException e) {
5106       {
5107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5108       };
5109     } catch (...) {
5110       {
5111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5112       };
5113     }
5114   }
5115
5116   jresult = result;
5117   return jresult;
5118 }
5119
5120
5121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5122   float jresult ;
5123   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5124   unsigned int arg2 ;
5125   float *result = 0 ;
5126
5127   arg1 = (Dali::Vector2 *)jarg1;
5128   arg2 = (unsigned int)jarg2;
5129   {
5130     try {
5131       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5132     } catch (std::out_of_range& e) {
5133       {
5134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5135       };
5136     } catch (std::exception& e) {
5137       {
5138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5139       };
5140     } catch (Dali::DaliException e) {
5141       {
5142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5143       };
5144     } catch (...) {
5145       {
5146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5147       };
5148     }
5149   }
5150
5151   jresult = *result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5157   float jresult ;
5158   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5159   float result;
5160
5161   arg1 = (Dali::Vector2 *)jarg1;
5162   {
5163     try {
5164       result = (float)((Dali::Vector2 const *)arg1)->Length();
5165     } catch (std::out_of_range& e) {
5166       {
5167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5168       };
5169     } catch (std::exception& e) {
5170       {
5171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5172       };
5173     } catch (Dali::DaliException e) {
5174       {
5175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5176       };
5177     } catch (...) {
5178       {
5179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5180       };
5181     }
5182   }
5183
5184   jresult = result;
5185   return jresult;
5186 }
5187
5188
5189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5190   float jresult ;
5191   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5192   float result;
5193
5194   arg1 = (Dali::Vector2 *)jarg1;
5195   {
5196     try {
5197       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5198     } catch (std::out_of_range& e) {
5199       {
5200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5201       };
5202     } catch (std::exception& e) {
5203       {
5204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5205       };
5206     } catch (Dali::DaliException e) {
5207       {
5208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5209       };
5210     } catch (...) {
5211       {
5212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5213       };
5214     }
5215   }
5216
5217   jresult = result;
5218   return jresult;
5219 }
5220
5221
5222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5223   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5224
5225   arg1 = (Dali::Vector2 *)jarg1;
5226   {
5227     try {
5228       (arg1)->Normalize();
5229     } catch (std::out_of_range& e) {
5230       {
5231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5232       };
5233     } catch (std::exception& e) {
5234       {
5235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5236       };
5237     } catch (Dali::DaliException e) {
5238       {
5239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5240       };
5241     } catch (...) {
5242       {
5243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5244       };
5245     }
5246   }
5247
5248 }
5249
5250
5251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5252   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5253   Dali::Vector2 *arg2 = 0 ;
5254   Dali::Vector2 *arg3 = 0 ;
5255
5256   arg1 = (Dali::Vector2 *)jarg1;
5257   arg2 = (Dali::Vector2 *)jarg2;
5258   if (!arg2) {
5259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5260     return ;
5261   }
5262   arg3 = (Dali::Vector2 *)jarg3;
5263   if (!arg3) {
5264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5265     return ;
5266   }
5267   {
5268     try {
5269       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5270     } catch (std::out_of_range& e) {
5271       {
5272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5273       };
5274     } catch (std::exception& e) {
5275       {
5276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5277       };
5278     } catch (Dali::DaliException e) {
5279       {
5280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5281       };
5282     } catch (...) {
5283       {
5284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5285       };
5286     }
5287   }
5288
5289 }
5290
5291
5292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5293   void * jresult ;
5294   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5295   float *result = 0 ;
5296
5297   arg1 = (Dali::Vector2 *)jarg1;
5298   {
5299     try {
5300       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5301     } catch (std::out_of_range& e) {
5302       {
5303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5304       };
5305     } catch (std::exception& e) {
5306       {
5307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5308       };
5309     } catch (Dali::DaliException e) {
5310       {
5311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5312       };
5313     } catch (...) {
5314       {
5315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5316       };
5317     }
5318   }
5319
5320   jresult = (void *)result;
5321   return jresult;
5322 }
5323
5324
5325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5326   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5327   float arg2 ;
5328
5329   arg1 = (Dali::Vector2 *)jarg1;
5330   arg2 = (float)jarg2;
5331   if (arg1) (arg1)->x = arg2;
5332 }
5333
5334
5335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5336   float jresult ;
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float result;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   result = (float) ((arg1)->x);
5342   jresult = result;
5343   return jresult;
5344 }
5345
5346
5347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float arg2 ;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   arg2 = (float)jarg2;
5353   if (arg1) (arg1)->width = arg2;
5354 }
5355
5356
5357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5358   float jresult ;
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float result;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   result = (float) ((arg1)->width);
5364   jresult = result;
5365   return jresult;
5366 }
5367
5368
5369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float arg2 ;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   arg2 = (float)jarg2;
5375   if (arg1) (arg1)->y = arg2;
5376 }
5377
5378
5379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5380   float jresult ;
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382   float result;
5383
5384   arg1 = (Dali::Vector2 *)jarg1;
5385   result = (float) ((arg1)->y);
5386   jresult = result;
5387   return jresult;
5388 }
5389
5390
5391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5392   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5393   float arg2 ;
5394
5395   arg1 = (Dali::Vector2 *)jarg1;
5396   arg2 = (float)jarg2;
5397   if (arg1) (arg1)->height = arg2;
5398 }
5399
5400
5401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5402   float jresult ;
5403   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5404   float result;
5405
5406   arg1 = (Dali::Vector2 *)jarg1;
5407   result = (float) ((arg1)->height);
5408   jresult = result;
5409   return jresult;
5410 }
5411
5412
5413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5414   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5415
5416   arg1 = (Dali::Vector2 *)jarg1;
5417   {
5418     try {
5419       delete arg1;
5420     } catch (std::out_of_range& e) {
5421       {
5422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5423       };
5424     } catch (std::exception& e) {
5425       {
5426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5427       };
5428     } catch (Dali::DaliException e) {
5429       {
5430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5431       };
5432     } catch (...) {
5433       {
5434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5435       };
5436     }
5437   }
5438
5439 }
5440
5441
5442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5443   void * jresult ;
5444   Dali::Vector2 *arg1 = 0 ;
5445   Dali::Vector2 *arg2 = 0 ;
5446   Dali::Vector2 result;
5447
5448   arg1 = (Dali::Vector2 *)jarg1;
5449   if (!arg1) {
5450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5451     return 0;
5452   }
5453   arg2 = (Dali::Vector2 *)jarg2;
5454   if (!arg2) {
5455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5456     return 0;
5457   }
5458   {
5459     try {
5460       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5461     } catch (std::out_of_range& e) {
5462       {
5463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5464       };
5465     } catch (std::exception& e) {
5466       {
5467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5468       };
5469     } catch (Dali::DaliException e) {
5470       {
5471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5472       };
5473     } catch (...) {
5474       {
5475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5476       };
5477     }
5478   }
5479
5480   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5481   return jresult;
5482 }
5483
5484
5485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5486   void * jresult ;
5487   Dali::Vector2 *arg1 = 0 ;
5488   Dali::Vector2 *arg2 = 0 ;
5489   Dali::Vector2 result;
5490
5491   arg1 = (Dali::Vector2 *)jarg1;
5492   if (!arg1) {
5493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5494     return 0;
5495   }
5496   arg2 = (Dali::Vector2 *)jarg2;
5497   if (!arg2) {
5498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5499     return 0;
5500   }
5501   {
5502     try {
5503       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5504     } catch (std::out_of_range& e) {
5505       {
5506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5507       };
5508     } catch (std::exception& e) {
5509       {
5510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5511       };
5512     } catch (Dali::DaliException e) {
5513       {
5514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5515       };
5516     } catch (...) {
5517       {
5518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5519       };
5520     }
5521   }
5522
5523   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5524   return jresult;
5525 }
5526
5527
5528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5529   void * jresult ;
5530   Dali::Vector2 *arg1 = 0 ;
5531   float *arg2 = 0 ;
5532   float *arg3 = 0 ;
5533   float temp2 ;
5534   float temp3 ;
5535   Dali::Vector2 result;
5536
5537   arg1 = (Dali::Vector2 *)jarg1;
5538   if (!arg1) {
5539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5540     return 0;
5541   }
5542   temp2 = (float)jarg2;
5543   arg2 = &temp2;
5544   temp3 = (float)jarg3;
5545   arg3 = &temp3;
5546   {
5547     try {
5548       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (Dali::DaliException e) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5560       };
5561     } catch (...) {
5562       {
5563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5564       };
5565     }
5566   }
5567
5568   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5569   return jresult;
5570 }
5571
5572
5573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5574   void * jresult ;
5575   Dali::Vector3 *result = 0 ;
5576
5577   {
5578     try {
5579       result = (Dali::Vector3 *)new Dali::Vector3();
5580     } catch (std::out_of_range& e) {
5581       {
5582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (std::exception& e) {
5585       {
5586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (Dali::DaliException e) {
5589       {
5590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5591       };
5592     } catch (...) {
5593       {
5594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5595       };
5596     }
5597   }
5598
5599   jresult = (void *)result;
5600   return jresult;
5601 }
5602
5603
5604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5605   void * jresult ;
5606   float arg1 ;
5607   float arg2 ;
5608   float arg3 ;
5609   Dali::Vector3 *result = 0 ;
5610
5611   arg1 = (float)jarg1;
5612   arg2 = (float)jarg2;
5613   arg3 = (float)jarg3;
5614   {
5615     try {
5616       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5617     } catch (std::out_of_range& e) {
5618       {
5619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5620       };
5621     } catch (std::exception& e) {
5622       {
5623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5624       };
5625     } catch (Dali::DaliException e) {
5626       {
5627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5628       };
5629     } catch (...) {
5630       {
5631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5632       };
5633     }
5634   }
5635
5636   jresult = (void *)result;
5637   return jresult;
5638 }
5639
5640
5641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5642   void * jresult ;
5643   float *arg1 = (float *) 0 ;
5644   Dali::Vector3 *result = 0 ;
5645
5646   arg1 = jarg1;
5647   {
5648     try {
5649       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5650     } catch (std::out_of_range& e) {
5651       {
5652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5653       };
5654     } catch (std::exception& e) {
5655       {
5656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5657       };
5658     } catch (Dali::DaliException e) {
5659       {
5660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5661       };
5662     } catch (...) {
5663       {
5664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5665       };
5666     }
5667   }
5668
5669   jresult = (void *)result;
5670
5671
5672   return jresult;
5673 }
5674
5675
5676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5677   void * jresult ;
5678   Dali::Vector2 *arg1 = 0 ;
5679   Dali::Vector3 *result = 0 ;
5680
5681   arg1 = (Dali::Vector2 *)jarg1;
5682   if (!arg1) {
5683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5684     return 0;
5685   }
5686   {
5687     try {
5688       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5689     } catch (std::out_of_range& e) {
5690       {
5691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5692       };
5693     } catch (std::exception& e) {
5694       {
5695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5696       };
5697     } catch (Dali::DaliException e) {
5698       {
5699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5700       };
5701     } catch (...) {
5702       {
5703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5704       };
5705     }
5706   }
5707
5708   jresult = (void *)result;
5709   return jresult;
5710 }
5711
5712
5713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5714   void * jresult ;
5715   Dali::Vector4 *arg1 = 0 ;
5716   Dali::Vector3 *result = 0 ;
5717
5718   arg1 = (Dali::Vector4 *)jarg1;
5719   if (!arg1) {
5720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5721     return 0;
5722   }
5723   {
5724     try {
5725       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5726     } catch (std::out_of_range& e) {
5727       {
5728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5729       };
5730     } catch (std::exception& e) {
5731       {
5732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5733       };
5734     } catch (Dali::DaliException e) {
5735       {
5736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5737       };
5738     } catch (...) {
5739       {
5740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5741       };
5742     }
5743   }
5744
5745   jresult = (void *)result;
5746   return jresult;
5747 }
5748
5749
5750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5751   void * jresult ;
5752   Dali::Vector3 *result = 0 ;
5753
5754   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5755   jresult = (void *)result;
5756   return jresult;
5757 }
5758
5759
5760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5761   void * jresult ;
5762   Dali::Vector3 *result = 0 ;
5763
5764   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5765   jresult = (void *)result;
5766   return jresult;
5767 }
5768
5769
5770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5771   void * jresult ;
5772   Dali::Vector3 *result = 0 ;
5773
5774   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5775   jresult = (void *)result;
5776   return jresult;
5777 }
5778
5779
5780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5781   void * jresult ;
5782   Dali::Vector3 *result = 0 ;
5783
5784   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5785   jresult = (void *)result;
5786   return jresult;
5787 }
5788
5789
5790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5791   void * jresult ;
5792   Dali::Vector3 *result = 0 ;
5793
5794   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5795   jresult = (void *)result;
5796   return jresult;
5797 }
5798
5799
5800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5801   void * jresult ;
5802   Dali::Vector3 *result = 0 ;
5803
5804   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5805   jresult = (void *)result;
5806   return jresult;
5807 }
5808
5809
5810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5811   void * jresult ;
5812   Dali::Vector3 *result = 0 ;
5813
5814   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5815   jresult = (void *)result;
5816   return jresult;
5817 }
5818
5819
5820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5821   void * jresult ;
5822   Dali::Vector3 *result = 0 ;
5823
5824   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5825   jresult = (void *)result;
5826   return jresult;
5827 }
5828
5829
5830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5831   void * jresult ;
5832   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5833   float *arg2 = (float *) 0 ;
5834   Dali::Vector3 *result = 0 ;
5835
5836   arg1 = (Dali::Vector3 *)jarg1;
5837   arg2 = jarg2;
5838   {
5839     try {
5840       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5841     } catch (std::out_of_range& e) {
5842       {
5843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5844       };
5845     } catch (std::exception& e) {
5846       {
5847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5848       };
5849     } catch (Dali::DaliException e) {
5850       {
5851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5852       };
5853     } catch (...) {
5854       {
5855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5856       };
5857     }
5858   }
5859
5860   jresult = (void *)result;
5861
5862
5863   return jresult;
5864 }
5865
5866
5867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5868   void * jresult ;
5869   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5870   Dali::Vector2 *arg2 = 0 ;
5871   Dali::Vector3 *result = 0 ;
5872
5873   arg1 = (Dali::Vector3 *)jarg1;
5874   arg2 = (Dali::Vector2 *)jarg2;
5875   if (!arg2) {
5876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5877     return 0;
5878   }
5879   {
5880     try {
5881       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5882     } catch (std::out_of_range& e) {
5883       {
5884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5885       };
5886     } catch (std::exception& e) {
5887       {
5888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (Dali::DaliException e) {
5891       {
5892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5893       };
5894     } catch (...) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5897       };
5898     }
5899   }
5900
5901   jresult = (void *)result;
5902   return jresult;
5903 }
5904
5905
5906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5907   void * jresult ;
5908   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5909   Dali::Vector4 *arg2 = 0 ;
5910   Dali::Vector3 *result = 0 ;
5911
5912   arg1 = (Dali::Vector3 *)jarg1;
5913   arg2 = (Dali::Vector4 *)jarg2;
5914   if (!arg2) {
5915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5916     return 0;
5917   }
5918   {
5919     try {
5920       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5921     } catch (std::out_of_range& e) {
5922       {
5923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5924       };
5925     } catch (std::exception& e) {
5926       {
5927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5928       };
5929     } catch (Dali::DaliException e) {
5930       {
5931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5932       };
5933     } catch (...) {
5934       {
5935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5936       };
5937     }
5938   }
5939
5940   jresult = (void *)result;
5941   return jresult;
5942 }
5943
5944
5945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5946   void * jresult ;
5947   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5948   Dali::Vector3 *arg2 = 0 ;
5949   Dali::Vector3 result;
5950
5951   arg1 = (Dali::Vector3 *)jarg1;
5952   arg2 = (Dali::Vector3 *)jarg2;
5953   if (!arg2) {
5954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5955     return 0;
5956   }
5957   {
5958     try {
5959       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5960     } catch (std::out_of_range& e) {
5961       {
5962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5963       };
5964     } catch (std::exception& e) {
5965       {
5966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5967       };
5968     } catch (Dali::DaliException e) {
5969       {
5970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5971       };
5972     } catch (...) {
5973       {
5974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5975       };
5976     }
5977   }
5978
5979   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5980   return jresult;
5981 }
5982
5983
5984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5985   void * jresult ;
5986   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5987   Dali::Vector3 *arg2 = 0 ;
5988   Dali::Vector3 *result = 0 ;
5989
5990   arg1 = (Dali::Vector3 *)jarg1;
5991   arg2 = (Dali::Vector3 *)jarg2;
5992   if (!arg2) {
5993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5994     return 0;
5995   }
5996   {
5997     try {
5998       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5999     } catch (std::out_of_range& e) {
6000       {
6001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6002       };
6003     } catch (std::exception& e) {
6004       {
6005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6006       };
6007     } catch (Dali::DaliException e) {
6008       {
6009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6010       };
6011     } catch (...) {
6012       {
6013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6014       };
6015     }
6016   }
6017
6018   jresult = (void *)result;
6019   return jresult;
6020 }
6021
6022
6023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6024   void * jresult ;
6025   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6026   Dali::Vector3 *arg2 = 0 ;
6027   Dali::Vector3 result;
6028
6029   arg1 = (Dali::Vector3 *)jarg1;
6030   arg2 = (Dali::Vector3 *)jarg2;
6031   if (!arg2) {
6032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6033     return 0;
6034   }
6035   {
6036     try {
6037       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6045       };
6046     } catch (Dali::DaliException e) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6049       };
6050     } catch (...) {
6051       {
6052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6053       };
6054     }
6055   }
6056
6057   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6058   return jresult;
6059 }
6060
6061
6062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6063   void * jresult ;
6064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6065   Dali::Vector3 *arg2 = 0 ;
6066   Dali::Vector3 *result = 0 ;
6067
6068   arg1 = (Dali::Vector3 *)jarg1;
6069   arg2 = (Dali::Vector3 *)jarg2;
6070   if (!arg2) {
6071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6072     return 0;
6073   }
6074   {
6075     try {
6076       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6077     } catch (std::out_of_range& e) {
6078       {
6079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6080       };
6081     } catch (std::exception& e) {
6082       {
6083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (Dali::DaliException e) {
6086       {
6087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6088       };
6089     } catch (...) {
6090       {
6091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6092       };
6093     }
6094   }
6095
6096   jresult = (void *)result;
6097   return jresult;
6098 }
6099
6100
6101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6102   void * jresult ;
6103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6104   Dali::Vector3 *arg2 = 0 ;
6105   Dali::Vector3 result;
6106
6107   arg1 = (Dali::Vector3 *)jarg1;
6108   arg2 = (Dali::Vector3 *)jarg2;
6109   if (!arg2) {
6110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6111     return 0;
6112   }
6113   {
6114     try {
6115       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6116     } catch (std::out_of_range& e) {
6117       {
6118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6119       };
6120     } catch (std::exception& e) {
6121       {
6122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (Dali::DaliException e) {
6125       {
6126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6127       };
6128     } catch (...) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6131       };
6132     }
6133   }
6134
6135   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6136   return jresult;
6137 }
6138
6139
6140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6141   void * jresult ;
6142   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6143   float arg2 ;
6144   Dali::Vector3 result;
6145
6146   arg1 = (Dali::Vector3 *)jarg1;
6147   arg2 = (float)jarg2;
6148   {
6149     try {
6150       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6151     } catch (std::out_of_range& e) {
6152       {
6153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6154       };
6155     } catch (std::exception& e) {
6156       {
6157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6158       };
6159     } catch (Dali::DaliException e) {
6160       {
6161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6162       };
6163     } catch (...) {
6164       {
6165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6166       };
6167     }
6168   }
6169
6170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6171   return jresult;
6172 }
6173
6174
6175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6176   void * jresult ;
6177   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6178   Dali::Vector3 *arg2 = 0 ;
6179   Dali::Vector3 *result = 0 ;
6180
6181   arg1 = (Dali::Vector3 *)jarg1;
6182   arg2 = (Dali::Vector3 *)jarg2;
6183   if (!arg2) {
6184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6185     return 0;
6186   }
6187   {
6188     try {
6189       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6190     } catch (std::out_of_range& e) {
6191       {
6192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6193       };
6194     } catch (std::exception& e) {
6195       {
6196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (Dali::DaliException e) {
6199       {
6200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6201       };
6202     } catch (...) {
6203       {
6204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6205       };
6206     }
6207   }
6208
6209   jresult = (void *)result;
6210   return jresult;
6211 }
6212
6213
6214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6215   void * jresult ;
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   float arg2 ;
6218   Dali::Vector3 *result = 0 ;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   arg2 = (float)jarg2;
6222   {
6223     try {
6224       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6225     } catch (std::out_of_range& e) {
6226       {
6227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6228       };
6229     } catch (std::exception& e) {
6230       {
6231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6232       };
6233     } catch (Dali::DaliException e) {
6234       {
6235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6236       };
6237     } catch (...) {
6238       {
6239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6240       };
6241     }
6242   }
6243
6244   jresult = (void *)result;
6245   return jresult;
6246 }
6247
6248
6249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6250   void * jresult ;
6251   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6252   Dali::Quaternion *arg2 = 0 ;
6253   Dali::Vector3 *result = 0 ;
6254
6255   arg1 = (Dali::Vector3 *)jarg1;
6256   arg2 = (Dali::Quaternion *)jarg2;
6257   if (!arg2) {
6258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6259     return 0;
6260   }
6261   {
6262     try {
6263       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6264     } catch (std::out_of_range& e) {
6265       {
6266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6267       };
6268     } catch (std::exception& e) {
6269       {
6270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6271       };
6272     } catch (Dali::DaliException e) {
6273       {
6274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6275       };
6276     } catch (...) {
6277       {
6278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6279       };
6280     }
6281   }
6282
6283   jresult = (void *)result;
6284   return jresult;
6285 }
6286
6287
6288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6289   void * jresult ;
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   Dali::Vector3 *arg2 = 0 ;
6292   Dali::Vector3 result;
6293
6294   arg1 = (Dali::Vector3 *)jarg1;
6295   arg2 = (Dali::Vector3 *)jarg2;
6296   if (!arg2) {
6297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6298     return 0;
6299   }
6300   {
6301     try {
6302       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6303     } catch (std::out_of_range& e) {
6304       {
6305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6306       };
6307     } catch (std::exception& e) {
6308       {
6309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6310       };
6311     } catch (Dali::DaliException e) {
6312       {
6313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6314       };
6315     } catch (...) {
6316       {
6317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6318       };
6319     }
6320   }
6321
6322   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6328   void * jresult ;
6329   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6330   float arg2 ;
6331   Dali::Vector3 result;
6332
6333   arg1 = (Dali::Vector3 *)jarg1;
6334   arg2 = (float)jarg2;
6335   {
6336     try {
6337       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6338     } catch (std::out_of_range& e) {
6339       {
6340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6341       };
6342     } catch (std::exception& e) {
6343       {
6344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6345       };
6346     } catch (Dali::DaliException e) {
6347       {
6348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6349       };
6350     } catch (...) {
6351       {
6352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6353       };
6354     }
6355   }
6356
6357   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6358   return jresult;
6359 }
6360
6361
6362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6363   void * jresult ;
6364   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6365   Dali::Vector3 *arg2 = 0 ;
6366   Dali::Vector3 *result = 0 ;
6367
6368   arg1 = (Dali::Vector3 *)jarg1;
6369   arg2 = (Dali::Vector3 *)jarg2;
6370   if (!arg2) {
6371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6372     return 0;
6373   }
6374   {
6375     try {
6376       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6377     } catch (std::out_of_range& e) {
6378       {
6379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6380       };
6381     } catch (std::exception& e) {
6382       {
6383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (Dali::DaliException e) {
6386       {
6387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6388       };
6389     } catch (...) {
6390       {
6391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6392       };
6393     }
6394   }
6395
6396   jresult = (void *)result;
6397   return jresult;
6398 }
6399
6400
6401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6402   void * jresult ;
6403   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6404   float arg2 ;
6405   Dali::Vector3 *result = 0 ;
6406
6407   arg1 = (Dali::Vector3 *)jarg1;
6408   arg2 = (float)jarg2;
6409   {
6410     try {
6411       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6412     } catch (std::out_of_range& e) {
6413       {
6414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6415       };
6416     } catch (std::exception& e) {
6417       {
6418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6419       };
6420     } catch (Dali::DaliException e) {
6421       {
6422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6423       };
6424     } catch (...) {
6425       {
6426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6427       };
6428     }
6429   }
6430
6431   jresult = (void *)result;
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6437   void * jresult ;
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439   Dali::Vector3 result;
6440
6441   arg1 = (Dali::Vector3 *)jarg1;
6442   {
6443     try {
6444       result = ((Dali::Vector3 const *)arg1)->operator -();
6445     } catch (std::out_of_range& e) {
6446       {
6447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6448       };
6449     } catch (std::exception& e) {
6450       {
6451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6452       };
6453     } catch (Dali::DaliException e) {
6454       {
6455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6456       };
6457     } catch (...) {
6458       {
6459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6460       };
6461     }
6462   }
6463
6464   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6465   return jresult;
6466 }
6467
6468
6469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6470   unsigned int jresult ;
6471   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6472   Dali::Vector3 *arg2 = 0 ;
6473   bool result;
6474
6475   arg1 = (Dali::Vector3 *)jarg1;
6476   arg2 = (Dali::Vector3 *)jarg2;
6477   if (!arg2) {
6478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6479     return 0;
6480   }
6481   {
6482     try {
6483       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6484     } catch (std::out_of_range& e) {
6485       {
6486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (std::exception& e) {
6489       {
6490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6491       };
6492     } catch (Dali::DaliException e) {
6493       {
6494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6495       };
6496     } catch (...) {
6497       {
6498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6499       };
6500     }
6501   }
6502
6503   jresult = result;
6504   return jresult;
6505 }
6506
6507
6508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6509   unsigned int jresult ;
6510   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6511   Dali::Vector3 *arg2 = 0 ;
6512   bool result;
6513
6514   arg1 = (Dali::Vector3 *)jarg1;
6515   arg2 = (Dali::Vector3 *)jarg2;
6516   if (!arg2) {
6517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6518     return 0;
6519   }
6520   {
6521     try {
6522       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6523     } catch (std::out_of_range& e) {
6524       {
6525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6526       };
6527     } catch (std::exception& e) {
6528       {
6529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6530       };
6531     } catch (Dali::DaliException e) {
6532       {
6533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6534       };
6535     } catch (...) {
6536       {
6537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6538       };
6539     }
6540   }
6541
6542   jresult = result;
6543   return jresult;
6544 }
6545
6546
6547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6548   float jresult ;
6549   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6550   unsigned int arg2 ;
6551   float *result = 0 ;
6552
6553   arg1 = (Dali::Vector3 *)jarg1;
6554   arg2 = (unsigned int)jarg2;
6555   {
6556     try {
6557       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6558     } catch (std::out_of_range& e) {
6559       {
6560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6561       };
6562     } catch (std::exception& e) {
6563       {
6564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (Dali::DaliException e) {
6567       {
6568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6569       };
6570     } catch (...) {
6571       {
6572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6573       };
6574     }
6575   }
6576
6577   jresult = *result;
6578   return jresult;
6579 }
6580
6581
6582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6583   float jresult ;
6584   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6585   Dali::Vector3 *arg2 = 0 ;
6586   float result;
6587
6588   arg1 = (Dali::Vector3 *)jarg1;
6589   arg2 = (Dali::Vector3 *)jarg2;
6590   if (!arg2) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (Dali::DaliException e) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6608       };
6609     } catch (...) {
6610       {
6611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6612       };
6613     }
6614   }
6615
6616   jresult = result;
6617   return jresult;
6618 }
6619
6620
6621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6622   void * jresult ;
6623   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6624   Dali::Vector3 *arg2 = 0 ;
6625   Dali::Vector3 result;
6626
6627   arg1 = (Dali::Vector3 *)jarg1;
6628   arg2 = (Dali::Vector3 *)jarg2;
6629   if (!arg2) {
6630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6631     return 0;
6632   }
6633   {
6634     try {
6635       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6636     } catch (std::out_of_range& e) {
6637       {
6638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6639       };
6640     } catch (std::exception& e) {
6641       {
6642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6643       };
6644     } catch (Dali::DaliException e) {
6645       {
6646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6647       };
6648     } catch (...) {
6649       {
6650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6651       };
6652     }
6653   }
6654
6655   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6661   float jresult ;
6662   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6663   float result;
6664
6665   arg1 = (Dali::Vector3 *)jarg1;
6666   {
6667     try {
6668       result = (float)((Dali::Vector3 const *)arg1)->Length();
6669     } catch (std::out_of_range& e) {
6670       {
6671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6672       };
6673     } catch (std::exception& e) {
6674       {
6675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6676       };
6677     } catch (Dali::DaliException e) {
6678       {
6679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6680       };
6681     } catch (...) {
6682       {
6683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6684       };
6685     }
6686   }
6687
6688   jresult = result;
6689   return jresult;
6690 }
6691
6692
6693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6694   float jresult ;
6695   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6696   float result;
6697
6698   arg1 = (Dali::Vector3 *)jarg1;
6699   {
6700     try {
6701       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6702     } catch (std::out_of_range& e) {
6703       {
6704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6705       };
6706     } catch (std::exception& e) {
6707       {
6708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6709       };
6710     } catch (Dali::DaliException e) {
6711       {
6712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6713       };
6714     } catch (...) {
6715       {
6716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6717       };
6718     }
6719   }
6720
6721   jresult = result;
6722   return jresult;
6723 }
6724
6725
6726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6727   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6728
6729   arg1 = (Dali::Vector3 *)jarg1;
6730   {
6731     try {
6732       (arg1)->Normalize();
6733     } catch (std::out_of_range& e) {
6734       {
6735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6736       };
6737     } catch (std::exception& e) {
6738       {
6739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6740       };
6741     } catch (Dali::DaliException e) {
6742       {
6743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6744       };
6745     } catch (...) {
6746       {
6747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6748       };
6749     }
6750   }
6751
6752 }
6753
6754
6755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6756   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6757   Dali::Vector3 *arg2 = 0 ;
6758   Dali::Vector3 *arg3 = 0 ;
6759
6760   arg1 = (Dali::Vector3 *)jarg1;
6761   arg2 = (Dali::Vector3 *)jarg2;
6762   if (!arg2) {
6763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6764     return ;
6765   }
6766   arg3 = (Dali::Vector3 *)jarg3;
6767   if (!arg3) {
6768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6769     return ;
6770   }
6771   {
6772     try {
6773       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6774     } catch (std::out_of_range& e) {
6775       {
6776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6777       };
6778     } catch (std::exception& e) {
6779       {
6780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6781       };
6782     } catch (Dali::DaliException e) {
6783       {
6784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6785       };
6786     } catch (...) {
6787       {
6788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6789       };
6790     }
6791   }
6792
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6797   void * jresult ;
6798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6799   float *result = 0 ;
6800
6801   arg1 = (Dali::Vector3 *)jarg1;
6802   {
6803     try {
6804       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6805     } catch (std::out_of_range& e) {
6806       {
6807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6808       };
6809     } catch (std::exception& e) {
6810       {
6811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6812       };
6813     } catch (Dali::DaliException e) {
6814       {
6815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6816       };
6817     } catch (...) {
6818       {
6819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6820       };
6821     }
6822   }
6823
6824   jresult = (void *)result;
6825   return jresult;
6826 }
6827
6828
6829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6830   void * jresult ;
6831   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6832   Dali::Vector2 *result = 0 ;
6833
6834   arg1 = (Dali::Vector3 *)jarg1;
6835   {
6836     try {
6837       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6838     } catch (std::out_of_range& e) {
6839       {
6840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6841       };
6842     } catch (std::exception& e) {
6843       {
6844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (Dali::DaliException e) {
6847       {
6848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6849       };
6850     } catch (...) {
6851       {
6852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6853       };
6854     }
6855   }
6856
6857   jresult = (void *)result;
6858   return jresult;
6859 }
6860
6861
6862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6863   void * jresult ;
6864   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6865   Dali::Vector2 *result = 0 ;
6866
6867   arg1 = (Dali::Vector3 *)jarg1;
6868   {
6869     try {
6870       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6871     } catch (std::out_of_range& e) {
6872       {
6873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6874       };
6875     } catch (std::exception& e) {
6876       {
6877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6878       };
6879     } catch (Dali::DaliException e) {
6880       {
6881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6882       };
6883     } catch (...) {
6884       {
6885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6886       };
6887     }
6888   }
6889
6890   jresult = (void *)result;
6891   return jresult;
6892 }
6893
6894
6895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6896   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6897   float arg2 ;
6898
6899   arg1 = (Dali::Vector3 *)jarg1;
6900   arg2 = (float)jarg2;
6901   if (arg1) (arg1)->x = arg2;
6902 }
6903
6904
6905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6906   float jresult ;
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float result;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   result = (float) ((arg1)->x);
6912   jresult = result;
6913   return jresult;
6914 }
6915
6916
6917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float arg2 ;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   arg2 = (float)jarg2;
6923   if (arg1) (arg1)->width = arg2;
6924 }
6925
6926
6927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6928   float jresult ;
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float result;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   result = (float) ((arg1)->width);
6934   jresult = result;
6935   return jresult;
6936 }
6937
6938
6939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float arg2 ;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   arg2 = (float)jarg2;
6945   if (arg1) (arg1)->r = arg2;
6946 }
6947
6948
6949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6950   float jresult ;
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float result;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   result = (float) ((arg1)->r);
6956   jresult = result;
6957   return jresult;
6958 }
6959
6960
6961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float arg2 ;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   arg2 = (float)jarg2;
6967   if (arg1) (arg1)->y = arg2;
6968 }
6969
6970
6971 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6972   float jresult ;
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float result;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   result = (float) ((arg1)->y);
6978   jresult = result;
6979   return jresult;
6980 }
6981
6982
6983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float arg2 ;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   arg2 = (float)jarg2;
6989   if (arg1) (arg1)->height = arg2;
6990 }
6991
6992
6993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6994   float jresult ;
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float result;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   result = (float) ((arg1)->height);
7000   jresult = result;
7001   return jresult;
7002 }
7003
7004
7005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float arg2 ;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   arg2 = (float)jarg2;
7011   if (arg1) (arg1)->g = arg2;
7012 }
7013
7014
7015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7016   float jresult ;
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float result;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   result = (float) ((arg1)->g);
7022   jresult = result;
7023   return jresult;
7024 }
7025
7026
7027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float arg2 ;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   arg2 = (float)jarg2;
7033   if (arg1) (arg1)->z = arg2;
7034 }
7035
7036
7037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7038   float jresult ;
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float result;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   result = (float) ((arg1)->z);
7044   jresult = result;
7045   return jresult;
7046 }
7047
7048
7049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float arg2 ;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   arg2 = (float)jarg2;
7055   if (arg1) (arg1)->depth = arg2;
7056 }
7057
7058
7059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7060   float jresult ;
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062   float result;
7063
7064   arg1 = (Dali::Vector3 *)jarg1;
7065   result = (float) ((arg1)->depth);
7066   jresult = result;
7067   return jresult;
7068 }
7069
7070
7071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7073   float arg2 ;
7074
7075   arg1 = (Dali::Vector3 *)jarg1;
7076   arg2 = (float)jarg2;
7077   if (arg1) (arg1)->b = arg2;
7078 }
7079
7080
7081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7082   float jresult ;
7083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7084   float result;
7085
7086   arg1 = (Dali::Vector3 *)jarg1;
7087   result = (float) ((arg1)->b);
7088   jresult = result;
7089   return jresult;
7090 }
7091
7092
7093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7094   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7095
7096   arg1 = (Dali::Vector3 *)jarg1;
7097   {
7098     try {
7099       delete arg1;
7100     } catch (std::out_of_range& e) {
7101       {
7102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7103       };
7104     } catch (std::exception& e) {
7105       {
7106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7107       };
7108     } catch (Dali::DaliException e) {
7109       {
7110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7111       };
7112     } catch (...) {
7113       {
7114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7115       };
7116     }
7117   }
7118
7119 }
7120
7121
7122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7123   void * jresult ;
7124   Dali::Vector3 *arg1 = 0 ;
7125   Dali::Vector3 *arg2 = 0 ;
7126   Dali::Vector3 result;
7127
7128   arg1 = (Dali::Vector3 *)jarg1;
7129   if (!arg1) {
7130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7131     return 0;
7132   }
7133   arg2 = (Dali::Vector3 *)jarg2;
7134   if (!arg2) {
7135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7136     return 0;
7137   }
7138   {
7139     try {
7140       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7141     } catch (std::out_of_range& e) {
7142       {
7143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7144       };
7145     } catch (std::exception& e) {
7146       {
7147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7148       };
7149     } catch (Dali::DaliException e) {
7150       {
7151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7152       };
7153     } catch (...) {
7154       {
7155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7156       };
7157     }
7158   }
7159
7160   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7161   return jresult;
7162 }
7163
7164
7165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7166   void * jresult ;
7167   Dali::Vector3 *arg1 = 0 ;
7168   Dali::Vector3 *arg2 = 0 ;
7169   Dali::Vector3 result;
7170
7171   arg1 = (Dali::Vector3 *)jarg1;
7172   if (!arg1) {
7173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7174     return 0;
7175   }
7176   arg2 = (Dali::Vector3 *)jarg2;
7177   if (!arg2) {
7178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7179     return 0;
7180   }
7181   {
7182     try {
7183       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7184     } catch (std::out_of_range& e) {
7185       {
7186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7187       };
7188     } catch (std::exception& e) {
7189       {
7190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7191       };
7192     } catch (Dali::DaliException e) {
7193       {
7194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7195       };
7196     } catch (...) {
7197       {
7198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7199       };
7200     }
7201   }
7202
7203   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7204   return jresult;
7205 }
7206
7207
7208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7209   void * jresult ;
7210   Dali::Vector3 *arg1 = 0 ;
7211   float *arg2 = 0 ;
7212   float *arg3 = 0 ;
7213   float temp2 ;
7214   float temp3 ;
7215   Dali::Vector3 result;
7216
7217   arg1 = (Dali::Vector3 *)jarg1;
7218   if (!arg1) {
7219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7220     return 0;
7221   }
7222   temp2 = (float)jarg2;
7223   arg2 = &temp2;
7224   temp3 = (float)jarg3;
7225   arg3 = &temp3;
7226   {
7227     try {
7228       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7229     } catch (std::out_of_range& e) {
7230       {
7231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7232       };
7233     } catch (std::exception& e) {
7234       {
7235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7236       };
7237     } catch (Dali::DaliException e) {
7238       {
7239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7240       };
7241     } catch (...) {
7242       {
7243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7244       };
7245     }
7246   }
7247
7248   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7254   void * jresult ;
7255   Dali::Vector4 *result = 0 ;
7256
7257   {
7258     try {
7259       result = (Dali::Vector4 *)new Dali::Vector4();
7260     } catch (std::out_of_range& e) {
7261       {
7262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7263       };
7264     } catch (std::exception& e) {
7265       {
7266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7267       };
7268     } catch (Dali::DaliException e) {
7269       {
7270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7271       };
7272     } catch (...) {
7273       {
7274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7275       };
7276     }
7277   }
7278
7279   jresult = (void *)result;
7280   return jresult;
7281 }
7282
7283
7284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7285   void * jresult ;
7286   float arg1 ;
7287   float arg2 ;
7288   float arg3 ;
7289   float arg4 ;
7290   Dali::Vector4 *result = 0 ;
7291
7292   arg1 = (float)jarg1;
7293   arg2 = (float)jarg2;
7294   arg3 = (float)jarg3;
7295   arg4 = (float)jarg4;
7296   {
7297     try {
7298       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7299     } catch (std::out_of_range& e) {
7300       {
7301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7302       };
7303     } catch (std::exception& e) {
7304       {
7305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7306       };
7307     } catch (Dali::DaliException e) {
7308       {
7309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7310       };
7311     } catch (...) {
7312       {
7313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7314       };
7315     }
7316   }
7317
7318   jresult = (void *)result;
7319   return jresult;
7320 }
7321
7322
7323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7324   void * jresult ;
7325   float *arg1 = (float *) 0 ;
7326   Dali::Vector4 *result = 0 ;
7327
7328   arg1 = jarg1;
7329   {
7330     try {
7331       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7332     } catch (std::out_of_range& e) {
7333       {
7334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7335       };
7336     } catch (std::exception& e) {
7337       {
7338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7339       };
7340     } catch (Dali::DaliException e) {
7341       {
7342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7343       };
7344     } catch (...) {
7345       {
7346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7347       };
7348     }
7349   }
7350
7351   jresult = (void *)result;
7352
7353
7354   return jresult;
7355 }
7356
7357
7358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7359   void * jresult ;
7360   Dali::Vector2 *arg1 = 0 ;
7361   Dali::Vector4 *result = 0 ;
7362
7363   arg1 = (Dali::Vector2 *)jarg1;
7364   if (!arg1) {
7365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7366     return 0;
7367   }
7368   {
7369     try {
7370       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7371     } catch (std::out_of_range& e) {
7372       {
7373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7374       };
7375     } catch (std::exception& e) {
7376       {
7377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7378       };
7379     } catch (Dali::DaliException e) {
7380       {
7381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7382       };
7383     } catch (...) {
7384       {
7385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7386       };
7387     }
7388   }
7389
7390   jresult = (void *)result;
7391   return jresult;
7392 }
7393
7394
7395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7396   void * jresult ;
7397   Dali::Vector3 *arg1 = 0 ;
7398   Dali::Vector4 *result = 0 ;
7399
7400   arg1 = (Dali::Vector3 *)jarg1;
7401   if (!arg1) {
7402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7403     return 0;
7404   }
7405   {
7406     try {
7407       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7408     } catch (std::out_of_range& e) {
7409       {
7410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7411       };
7412     } catch (std::exception& e) {
7413       {
7414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7415       };
7416     } catch (Dali::DaliException e) {
7417       {
7418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7419       };
7420     } catch (...) {
7421       {
7422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7423       };
7424     }
7425   }
7426
7427   jresult = (void *)result;
7428   return jresult;
7429 }
7430
7431
7432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7433   void * jresult ;
7434   Dali::Vector4 *result = 0 ;
7435
7436   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7437   jresult = (void *)result;
7438   return jresult;
7439 }
7440
7441
7442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7443   void * jresult ;
7444   Dali::Vector4 *result = 0 ;
7445
7446   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7447   jresult = (void *)result;
7448   return jresult;
7449 }
7450
7451
7452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7453   void * jresult ;
7454   Dali::Vector4 *result = 0 ;
7455
7456   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7457   jresult = (void *)result;
7458   return jresult;
7459 }
7460
7461
7462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7463   void * jresult ;
7464   Dali::Vector4 *result = 0 ;
7465
7466   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7467   jresult = (void *)result;
7468   return jresult;
7469 }
7470
7471
7472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7473   void * jresult ;
7474   Dali::Vector4 *result = 0 ;
7475
7476   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7477   jresult = (void *)result;
7478   return jresult;
7479 }
7480
7481
7482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7483   void * jresult ;
7484   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7485   float *arg2 = (float *) 0 ;
7486   Dali::Vector4 *result = 0 ;
7487
7488   arg1 = (Dali::Vector4 *)jarg1;
7489   arg2 = jarg2;
7490   {
7491     try {
7492       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7493     } catch (std::out_of_range& e) {
7494       {
7495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7496       };
7497     } catch (std::exception& e) {
7498       {
7499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7500       };
7501     } catch (Dali::DaliException e) {
7502       {
7503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7504       };
7505     } catch (...) {
7506       {
7507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7508       };
7509     }
7510   }
7511
7512   jresult = (void *)result;
7513
7514
7515   return jresult;
7516 }
7517
7518
7519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7520   void * jresult ;
7521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7522   Dali::Vector2 *arg2 = 0 ;
7523   Dali::Vector4 *result = 0 ;
7524
7525   arg1 = (Dali::Vector4 *)jarg1;
7526   arg2 = (Dali::Vector2 *)jarg2;
7527   if (!arg2) {
7528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7529     return 0;
7530   }
7531   {
7532     try {
7533       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7534     } catch (std::out_of_range& e) {
7535       {
7536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7537       };
7538     } catch (std::exception& e) {
7539       {
7540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7541       };
7542     } catch (Dali::DaliException e) {
7543       {
7544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7545       };
7546     } catch (...) {
7547       {
7548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7549       };
7550     }
7551   }
7552
7553   jresult = (void *)result;
7554   return jresult;
7555 }
7556
7557
7558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7559   void * jresult ;
7560   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7561   Dali::Vector3 *arg2 = 0 ;
7562   Dali::Vector4 *result = 0 ;
7563
7564   arg1 = (Dali::Vector4 *)jarg1;
7565   arg2 = (Dali::Vector3 *)jarg2;
7566   if (!arg2) {
7567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7568     return 0;
7569   }
7570   {
7571     try {
7572       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7573     } catch (std::out_of_range& e) {
7574       {
7575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7576       };
7577     } catch (std::exception& e) {
7578       {
7579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7580       };
7581     } catch (Dali::DaliException e) {
7582       {
7583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7584       };
7585     } catch (...) {
7586       {
7587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7588       };
7589     }
7590   }
7591
7592   jresult = (void *)result;
7593   return jresult;
7594 }
7595
7596
7597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7598   void * jresult ;
7599   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7600   Dali::Vector4 *arg2 = 0 ;
7601   Dali::Vector4 result;
7602
7603   arg1 = (Dali::Vector4 *)jarg1;
7604   arg2 = (Dali::Vector4 *)jarg2;
7605   if (!arg2) {
7606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7607     return 0;
7608   }
7609   {
7610     try {
7611       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7612     } catch (std::out_of_range& e) {
7613       {
7614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7615       };
7616     } catch (std::exception& e) {
7617       {
7618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7619       };
7620     } catch (Dali::DaliException e) {
7621       {
7622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7623       };
7624     } catch (...) {
7625       {
7626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7627       };
7628     }
7629   }
7630
7631   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7632   return jresult;
7633 }
7634
7635
7636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7637   void * jresult ;
7638   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7639   Dali::Vector4 *arg2 = 0 ;
7640   Dali::Vector4 *result = 0 ;
7641
7642   arg1 = (Dali::Vector4 *)jarg1;
7643   arg2 = (Dali::Vector4 *)jarg2;
7644   if (!arg2) {
7645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7646     return 0;
7647   }
7648   {
7649     try {
7650       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7651     } catch (std::out_of_range& e) {
7652       {
7653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7654       };
7655     } catch (std::exception& e) {
7656       {
7657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7658       };
7659     } catch (Dali::DaliException e) {
7660       {
7661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7662       };
7663     } catch (...) {
7664       {
7665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7666       };
7667     }
7668   }
7669
7670   jresult = (void *)result;
7671   return jresult;
7672 }
7673
7674
7675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7676   void * jresult ;
7677   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7678   Dali::Vector4 *arg2 = 0 ;
7679   Dali::Vector4 result;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   arg2 = (Dali::Vector4 *)jarg2;
7683   if (!arg2) {
7684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7685     return 0;
7686   }
7687   {
7688     try {
7689       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7690     } catch (std::out_of_range& e) {
7691       {
7692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7693       };
7694     } catch (std::exception& e) {
7695       {
7696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7697       };
7698     } catch (Dali::DaliException e) {
7699       {
7700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7701       };
7702     } catch (...) {
7703       {
7704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7705       };
7706     }
7707   }
7708
7709   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7710   return jresult;
7711 }
7712
7713
7714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7715   void * jresult ;
7716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7717   Dali::Vector4 *arg2 = 0 ;
7718   Dali::Vector4 *result = 0 ;
7719
7720   arg1 = (Dali::Vector4 *)jarg1;
7721   arg2 = (Dali::Vector4 *)jarg2;
7722   if (!arg2) {
7723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7724     return 0;
7725   }
7726   {
7727     try {
7728       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7729     } catch (std::out_of_range& e) {
7730       {
7731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7732       };
7733     } catch (std::exception& e) {
7734       {
7735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7736       };
7737     } catch (Dali::DaliException e) {
7738       {
7739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7740       };
7741     } catch (...) {
7742       {
7743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7744       };
7745     }
7746   }
7747
7748   jresult = (void *)result;
7749   return jresult;
7750 }
7751
7752
7753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7754   void * jresult ;
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   Dali::Vector4 *arg2 = 0 ;
7757   Dali::Vector4 result;
7758
7759   arg1 = (Dali::Vector4 *)jarg1;
7760   arg2 = (Dali::Vector4 *)jarg2;
7761   if (!arg2) {
7762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7763     return 0;
7764   }
7765   {
7766     try {
7767       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7768     } catch (std::out_of_range& e) {
7769       {
7770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7771       };
7772     } catch (std::exception& e) {
7773       {
7774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7775       };
7776     } catch (Dali::DaliException e) {
7777       {
7778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7779       };
7780     } catch (...) {
7781       {
7782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7783       };
7784     }
7785   }
7786
7787   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7788   return jresult;
7789 }
7790
7791
7792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7793   void * jresult ;
7794   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7795   float arg2 ;
7796   Dali::Vector4 result;
7797
7798   arg1 = (Dali::Vector4 *)jarg1;
7799   arg2 = (float)jarg2;
7800   {
7801     try {
7802       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7803     } catch (std::out_of_range& e) {
7804       {
7805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7806       };
7807     } catch (std::exception& e) {
7808       {
7809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7810       };
7811     } catch (Dali::DaliException e) {
7812       {
7813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7814       };
7815     } catch (...) {
7816       {
7817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7818       };
7819     }
7820   }
7821
7822   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7823   return jresult;
7824 }
7825
7826
7827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7828   void * jresult ;
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830   Dali::Vector4 *arg2 = 0 ;
7831   Dali::Vector4 *result = 0 ;
7832
7833   arg1 = (Dali::Vector4 *)jarg1;
7834   arg2 = (Dali::Vector4 *)jarg2;
7835   if (!arg2) {
7836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7837     return 0;
7838   }
7839   {
7840     try {
7841       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7842     } catch (std::out_of_range& e) {
7843       {
7844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7845       };
7846     } catch (std::exception& e) {
7847       {
7848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (Dali::DaliException e) {
7851       {
7852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7853       };
7854     } catch (...) {
7855       {
7856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7857       };
7858     }
7859   }
7860
7861   jresult = (void *)result;
7862   return jresult;
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7867   void * jresult ;
7868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7869   float arg2 ;
7870   Dali::Vector4 *result = 0 ;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   arg2 = (float)jarg2;
7874   {
7875     try {
7876       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7877     } catch (std::out_of_range& e) {
7878       {
7879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7880       };
7881     } catch (std::exception& e) {
7882       {
7883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7884       };
7885     } catch (Dali::DaliException e) {
7886       {
7887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7888       };
7889     } catch (...) {
7890       {
7891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7892       };
7893     }
7894   }
7895
7896   jresult = (void *)result;
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7902   void * jresult ;
7903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7904   Dali::Vector4 *arg2 = 0 ;
7905   Dali::Vector4 result;
7906
7907   arg1 = (Dali::Vector4 *)jarg1;
7908   arg2 = (Dali::Vector4 *)jarg2;
7909   if (!arg2) {
7910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7911     return 0;
7912   }
7913   {
7914     try {
7915       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7916     } catch (std::out_of_range& e) {
7917       {
7918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7919       };
7920     } catch (std::exception& e) {
7921       {
7922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7923       };
7924     } catch (Dali::DaliException e) {
7925       {
7926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7927       };
7928     } catch (...) {
7929       {
7930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7931       };
7932     }
7933   }
7934
7935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7941   void * jresult ;
7942   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7943   float arg2 ;
7944   Dali::Vector4 result;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   arg2 = (float)jarg2;
7948   {
7949     try {
7950       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7951     } catch (std::out_of_range& e) {
7952       {
7953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7954       };
7955     } catch (std::exception& e) {
7956       {
7957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7958       };
7959     } catch (Dali::DaliException e) {
7960       {
7961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7962       };
7963     } catch (...) {
7964       {
7965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7966       };
7967     }
7968   }
7969
7970   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7971   return jresult;
7972 }
7973
7974
7975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7976   void * jresult ;
7977   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7978   Dali::Vector4 *arg2 = 0 ;
7979   Dali::Vector4 *result = 0 ;
7980
7981   arg1 = (Dali::Vector4 *)jarg1;
7982   arg2 = (Dali::Vector4 *)jarg2;
7983   if (!arg2) {
7984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7985     return 0;
7986   }
7987   {
7988     try {
7989       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7990     } catch (std::out_of_range& e) {
7991       {
7992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (std::exception& e) {
7995       {
7996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (Dali::DaliException e) {
7999       {
8000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8001       };
8002     } catch (...) {
8003       {
8004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8005       };
8006     }
8007   }
8008
8009   jresult = (void *)result;
8010   return jresult;
8011 }
8012
8013
8014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8015   void * jresult ;
8016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8017   float arg2 ;
8018   Dali::Vector4 *result = 0 ;
8019
8020   arg1 = (Dali::Vector4 *)jarg1;
8021   arg2 = (float)jarg2;
8022   {
8023     try {
8024       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8025     } catch (std::out_of_range& e) {
8026       {
8027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8028       };
8029     } catch (std::exception& e) {
8030       {
8031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8032       };
8033     } catch (Dali::DaliException e) {
8034       {
8035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8036       };
8037     } catch (...) {
8038       {
8039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8040       };
8041     }
8042   }
8043
8044   jresult = (void *)result;
8045   return jresult;
8046 }
8047
8048
8049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8050   void * jresult ;
8051   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8052   Dali::Vector4 result;
8053
8054   arg1 = (Dali::Vector4 *)jarg1;
8055   {
8056     try {
8057       result = ((Dali::Vector4 const *)arg1)->operator -();
8058     } catch (std::out_of_range& e) {
8059       {
8060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8061       };
8062     } catch (std::exception& e) {
8063       {
8064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8065       };
8066     } catch (Dali::DaliException e) {
8067       {
8068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8069       };
8070     } catch (...) {
8071       {
8072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8073       };
8074     }
8075   }
8076
8077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8078   return jresult;
8079 }
8080
8081
8082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8083   unsigned int jresult ;
8084   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8085   Dali::Vector4 *arg2 = 0 ;
8086   bool result;
8087
8088   arg1 = (Dali::Vector4 *)jarg1;
8089   arg2 = (Dali::Vector4 *)jarg2;
8090   if (!arg2) {
8091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8092     return 0;
8093   }
8094   {
8095     try {
8096       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8097     } catch (std::out_of_range& e) {
8098       {
8099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8100       };
8101     } catch (std::exception& e) {
8102       {
8103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8104       };
8105     } catch (Dali::DaliException e) {
8106       {
8107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8108       };
8109     } catch (...) {
8110       {
8111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8112       };
8113     }
8114   }
8115
8116   jresult = result;
8117   return jresult;
8118 }
8119
8120
8121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8122   unsigned int jresult ;
8123   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8124   Dali::Vector4 *arg2 = 0 ;
8125   bool result;
8126
8127   arg1 = (Dali::Vector4 *)jarg1;
8128   arg2 = (Dali::Vector4 *)jarg2;
8129   if (!arg2) {
8130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8131     return 0;
8132   }
8133   {
8134     try {
8135       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8136     } catch (std::out_of_range& e) {
8137       {
8138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (std::exception& e) {
8141       {
8142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8143       };
8144     } catch (Dali::DaliException e) {
8145       {
8146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8147       };
8148     } catch (...) {
8149       {
8150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8151       };
8152     }
8153   }
8154
8155   jresult = result;
8156   return jresult;
8157 }
8158
8159
8160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8161   float jresult ;
8162   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8163   unsigned int arg2 ;
8164   float *result = 0 ;
8165
8166   arg1 = (Dali::Vector4 *)jarg1;
8167   arg2 = (unsigned int)jarg2;
8168   {
8169     try {
8170       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8171     } catch (std::out_of_range& e) {
8172       {
8173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8174       };
8175     } catch (std::exception& e) {
8176       {
8177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8178       };
8179     } catch (Dali::DaliException e) {
8180       {
8181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8182       };
8183     } catch (...) {
8184       {
8185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8186       };
8187     }
8188   }
8189
8190   jresult = *result;
8191   return jresult;
8192 }
8193
8194
8195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8196   float jresult ;
8197   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8198   Dali::Vector3 *arg2 = 0 ;
8199   float result;
8200
8201   arg1 = (Dali::Vector4 *)jarg1;
8202   arg2 = (Dali::Vector3 *)jarg2;
8203   if (!arg2) {
8204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8205     return 0;
8206   }
8207   {
8208     try {
8209       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8210     } catch (std::out_of_range& e) {
8211       {
8212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8213       };
8214     } catch (std::exception& e) {
8215       {
8216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8217       };
8218     } catch (Dali::DaliException e) {
8219       {
8220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8225       };
8226     }
8227   }
8228
8229   jresult = result;
8230   return jresult;
8231 }
8232
8233
8234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8235   float jresult ;
8236   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8237   Dali::Vector4 *arg2 = 0 ;
8238   float result;
8239
8240   arg1 = (Dali::Vector4 *)jarg1;
8241   arg2 = (Dali::Vector4 *)jarg2;
8242   if (!arg2) {
8243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8244     return 0;
8245   }
8246   {
8247     try {
8248       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8249     } catch (std::out_of_range& e) {
8250       {
8251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8252       };
8253     } catch (std::exception& e) {
8254       {
8255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8256       };
8257     } catch (Dali::DaliException e) {
8258       {
8259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8260       };
8261     } catch (...) {
8262       {
8263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8264       };
8265     }
8266   }
8267
8268   jresult = result;
8269   return jresult;
8270 }
8271
8272
8273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8274   float jresult ;
8275   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8276   Dali::Vector4 *arg2 = 0 ;
8277   float result;
8278
8279   arg1 = (Dali::Vector4 *)jarg1;
8280   arg2 = (Dali::Vector4 *)jarg2;
8281   if (!arg2) {
8282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8283     return 0;
8284   }
8285   {
8286     try {
8287       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8288     } catch (std::out_of_range& e) {
8289       {
8290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8291       };
8292     } catch (std::exception& e) {
8293       {
8294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8295       };
8296     } catch (Dali::DaliException e) {
8297       {
8298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8299       };
8300     } catch (...) {
8301       {
8302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8303       };
8304     }
8305   }
8306
8307   jresult = result;
8308   return jresult;
8309 }
8310
8311
8312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8313   void * jresult ;
8314   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8315   Dali::Vector4 *arg2 = 0 ;
8316   Dali::Vector4 result;
8317
8318   arg1 = (Dali::Vector4 *)jarg1;
8319   arg2 = (Dali::Vector4 *)jarg2;
8320   if (!arg2) {
8321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8322     return 0;
8323   }
8324   {
8325     try {
8326       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8327     } catch (std::out_of_range& e) {
8328       {
8329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8330       };
8331     } catch (std::exception& e) {
8332       {
8333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8334       };
8335     } catch (Dali::DaliException e) {
8336       {
8337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8338       };
8339     } catch (...) {
8340       {
8341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8342       };
8343     }
8344   }
8345
8346   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8347   return jresult;
8348 }
8349
8350
8351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8352   float jresult ;
8353   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8354   float result;
8355
8356   arg1 = (Dali::Vector4 *)jarg1;
8357   {
8358     try {
8359       result = (float)((Dali::Vector4 const *)arg1)->Length();
8360     } catch (std::out_of_range& e) {
8361       {
8362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8363       };
8364     } catch (std::exception& e) {
8365       {
8366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8367       };
8368     } catch (Dali::DaliException e) {
8369       {
8370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8371       };
8372     } catch (...) {
8373       {
8374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8375       };
8376     }
8377   }
8378
8379   jresult = result;
8380   return jresult;
8381 }
8382
8383
8384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8385   float jresult ;
8386   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8387   float result;
8388
8389   arg1 = (Dali::Vector4 *)jarg1;
8390   {
8391     try {
8392       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8393     } catch (std::out_of_range& e) {
8394       {
8395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8396       };
8397     } catch (std::exception& e) {
8398       {
8399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8400       };
8401     } catch (Dali::DaliException e) {
8402       {
8403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8404       };
8405     } catch (...) {
8406       {
8407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8408       };
8409     }
8410   }
8411
8412   jresult = result;
8413   return jresult;
8414 }
8415
8416
8417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8418   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8419
8420   arg1 = (Dali::Vector4 *)jarg1;
8421   {
8422     try {
8423       (arg1)->Normalize();
8424     } catch (std::out_of_range& e) {
8425       {
8426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8427       };
8428     } catch (std::exception& e) {
8429       {
8430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8431       };
8432     } catch (Dali::DaliException e) {
8433       {
8434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8435       };
8436     } catch (...) {
8437       {
8438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8439       };
8440     }
8441   }
8442
8443 }
8444
8445
8446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8447   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8448   Dali::Vector4 *arg2 = 0 ;
8449   Dali::Vector4 *arg3 = 0 ;
8450
8451   arg1 = (Dali::Vector4 *)jarg1;
8452   arg2 = (Dali::Vector4 *)jarg2;
8453   if (!arg2) {
8454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8455     return ;
8456   }
8457   arg3 = (Dali::Vector4 *)jarg3;
8458   if (!arg3) {
8459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8460     return ;
8461   }
8462   {
8463     try {
8464       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8465     } catch (std::out_of_range& e) {
8466       {
8467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8468       };
8469     } catch (std::exception& e) {
8470       {
8471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8472       };
8473     } catch (Dali::DaliException e) {
8474       {
8475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8476       };
8477     } catch (...) {
8478       {
8479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8480       };
8481     }
8482   }
8483
8484 }
8485
8486
8487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8488   void * jresult ;
8489   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8490   float *result = 0 ;
8491
8492   arg1 = (Dali::Vector4 *)jarg1;
8493   {
8494     try {
8495       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8496     } catch (std::out_of_range& e) {
8497       {
8498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8499       };
8500     } catch (std::exception& e) {
8501       {
8502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8503       };
8504     } catch (Dali::DaliException e) {
8505       {
8506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8507       };
8508     } catch (...) {
8509       {
8510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8511       };
8512     }
8513   }
8514
8515   jresult = (void *)result;
8516   return jresult;
8517 }
8518
8519
8520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8522   float arg2 ;
8523
8524   arg1 = (Dali::Vector4 *)jarg1;
8525   arg2 = (float)jarg2;
8526   if (arg1) (arg1)->x = arg2;
8527 }
8528
8529
8530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8531   float jresult ;
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float result;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   result = (float) ((arg1)->x);
8537   jresult = result;
8538   return jresult;
8539 }
8540
8541
8542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float arg2 ;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   arg2 = (float)jarg2;
8548   if (arg1) (arg1)->r = arg2;
8549 }
8550
8551
8552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8553   float jresult ;
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float result;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   result = (float) ((arg1)->r);
8559   jresult = result;
8560   return jresult;
8561 }
8562
8563
8564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float arg2 ;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   arg2 = (float)jarg2;
8570   if (arg1) (arg1)->s = arg2;
8571 }
8572
8573
8574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8575   float jresult ;
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float result;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   result = (float) ((arg1)->s);
8581   jresult = result;
8582   return jresult;
8583 }
8584
8585
8586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float arg2 ;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   arg2 = (float)jarg2;
8592   if (arg1) (arg1)->y = arg2;
8593 }
8594
8595
8596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8597   float jresult ;
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float result;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   result = (float) ((arg1)->y);
8603   jresult = result;
8604   return jresult;
8605 }
8606
8607
8608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float arg2 ;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   arg2 = (float)jarg2;
8614   if (arg1) (arg1)->g = arg2;
8615 }
8616
8617
8618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8619   float jresult ;
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float result;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   result = (float) ((arg1)->g);
8625   jresult = result;
8626   return jresult;
8627 }
8628
8629
8630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float arg2 ;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   arg2 = (float)jarg2;
8636   if (arg1) (arg1)->t = arg2;
8637 }
8638
8639
8640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8641   float jresult ;
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float result;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   result = (float) ((arg1)->t);
8647   jresult = result;
8648   return jresult;
8649 }
8650
8651
8652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float arg2 ;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   arg2 = (float)jarg2;
8658   if (arg1) (arg1)->z = arg2;
8659 }
8660
8661
8662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8663   float jresult ;
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float result;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   result = (float) ((arg1)->z);
8669   jresult = result;
8670   return jresult;
8671 }
8672
8673
8674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float arg2 ;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   arg2 = (float)jarg2;
8680   if (arg1) (arg1)->b = arg2;
8681 }
8682
8683
8684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8685   float jresult ;
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float result;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   result = (float) ((arg1)->b);
8691   jresult = result;
8692   return jresult;
8693 }
8694
8695
8696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float arg2 ;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   arg2 = (float)jarg2;
8702   if (arg1) (arg1)->p = arg2;
8703 }
8704
8705
8706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8707   float jresult ;
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float result;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   result = (float) ((arg1)->p);
8713   jresult = result;
8714   return jresult;
8715 }
8716
8717
8718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float arg2 ;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   arg2 = (float)jarg2;
8724   if (arg1) (arg1)->w = arg2;
8725 }
8726
8727
8728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8729   float jresult ;
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float result;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   result = (float) ((arg1)->w);
8735   jresult = result;
8736   return jresult;
8737 }
8738
8739
8740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float arg2 ;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   arg2 = (float)jarg2;
8746   if (arg1) (arg1)->a = arg2;
8747 }
8748
8749
8750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8751   float jresult ;
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753   float result;
8754
8755   arg1 = (Dali::Vector4 *)jarg1;
8756   result = (float) ((arg1)->a);
8757   jresult = result;
8758   return jresult;
8759 }
8760
8761
8762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8764   float arg2 ;
8765
8766   arg1 = (Dali::Vector4 *)jarg1;
8767   arg2 = (float)jarg2;
8768   if (arg1) (arg1)->q = arg2;
8769 }
8770
8771
8772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8773   float jresult ;
8774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8775   float result;
8776
8777   arg1 = (Dali::Vector4 *)jarg1;
8778   result = (float) ((arg1)->q);
8779   jresult = result;
8780   return jresult;
8781 }
8782
8783
8784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8786
8787   arg1 = (Dali::Vector4 *)jarg1;
8788   {
8789     try {
8790       delete arg1;
8791     } catch (std::out_of_range& e) {
8792       {
8793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8794       };
8795     } catch (std::exception& e) {
8796       {
8797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8798       };
8799     } catch (Dali::DaliException e) {
8800       {
8801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8802       };
8803     } catch (...) {
8804       {
8805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8806       };
8807     }
8808   }
8809
8810 }
8811
8812
8813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8814   void * jresult ;
8815   Dali::Vector4 *arg1 = 0 ;
8816   Dali::Vector4 *arg2 = 0 ;
8817   Dali::Vector4 result;
8818
8819   arg1 = (Dali::Vector4 *)jarg1;
8820   if (!arg1) {
8821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8822     return 0;
8823   }
8824   arg2 = (Dali::Vector4 *)jarg2;
8825   if (!arg2) {
8826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8827     return 0;
8828   }
8829   {
8830     try {
8831       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8832     } catch (std::out_of_range& e) {
8833       {
8834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8835       };
8836     } catch (std::exception& e) {
8837       {
8838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8839       };
8840     } catch (Dali::DaliException e) {
8841       {
8842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8843       };
8844     } catch (...) {
8845       {
8846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8847       };
8848     }
8849   }
8850
8851   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8852   return jresult;
8853 }
8854
8855
8856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8857   void * jresult ;
8858   Dali::Vector4 *arg1 = 0 ;
8859   Dali::Vector4 *arg2 = 0 ;
8860   Dali::Vector4 result;
8861
8862   arg1 = (Dali::Vector4 *)jarg1;
8863   if (!arg1) {
8864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8865     return 0;
8866   }
8867   arg2 = (Dali::Vector4 *)jarg2;
8868   if (!arg2) {
8869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8870     return 0;
8871   }
8872   {
8873     try {
8874       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8875     } catch (std::out_of_range& e) {
8876       {
8877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8878       };
8879     } catch (std::exception& e) {
8880       {
8881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8882       };
8883     } catch (Dali::DaliException e) {
8884       {
8885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8886       };
8887     } catch (...) {
8888       {
8889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8890       };
8891     }
8892   }
8893
8894   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8895   return jresult;
8896 }
8897
8898
8899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8900   void * jresult ;
8901   Dali::Vector4 *arg1 = 0 ;
8902   float *arg2 = 0 ;
8903   float *arg3 = 0 ;
8904   float temp2 ;
8905   float temp3 ;
8906   Dali::Vector4 result;
8907
8908   arg1 = (Dali::Vector4 *)jarg1;
8909   if (!arg1) {
8910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8911     return 0;
8912   }
8913   temp2 = (float)jarg2;
8914   arg2 = &temp2;
8915   temp3 = (float)jarg3;
8916   arg3 = &temp3;
8917   {
8918     try {
8919       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8920     } catch (std::out_of_range& e) {
8921       {
8922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (std::exception& e) {
8925       {
8926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8927       };
8928     } catch (Dali::DaliException e) {
8929       {
8930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8931       };
8932     } catch (...) {
8933       {
8934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8935       };
8936     }
8937   }
8938
8939   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8940   return jresult;
8941 }
8942
8943
8944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8945   void * jresult ;
8946   Dali::Uint16Pair *result = 0 ;
8947
8948   {
8949     try {
8950       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8951     } catch (std::out_of_range& e) {
8952       {
8953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8954       };
8955     } catch (std::exception& e) {
8956       {
8957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (Dali::DaliException e) {
8960       {
8961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8962       };
8963     } catch (...) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8966       };
8967     }
8968   }
8969
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8976   void * jresult ;
8977   uint32_t arg1 ;
8978   uint32_t arg2 ;
8979   Dali::Uint16Pair *result = 0 ;
8980
8981   arg1 = (uint32_t)jarg1;
8982   arg2 = (uint32_t)jarg2;
8983   {
8984     try {
8985       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8986     } catch (std::out_of_range& e) {
8987       {
8988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8989       };
8990     } catch (std::exception& e) {
8991       {
8992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8993       };
8994     } catch (Dali::DaliException e) {
8995       {
8996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8997       };
8998     } catch (...) {
8999       {
9000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9001       };
9002     }
9003   }
9004
9005   jresult = (void *)result;
9006   return jresult;
9007 }
9008
9009
9010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9011   void * jresult ;
9012   Dali::Uint16Pair *arg1 = 0 ;
9013   Dali::Uint16Pair *result = 0 ;
9014
9015   arg1 = (Dali::Uint16Pair *)jarg1;
9016   if (!arg1) {
9017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9018     return 0;
9019   }
9020   {
9021     try {
9022       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9023     } catch (std::out_of_range& e) {
9024       {
9025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9026       };
9027     } catch (std::exception& e) {
9028       {
9029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9030       };
9031     } catch (Dali::DaliException e) {
9032       {
9033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9034       };
9035     } catch (...) {
9036       {
9037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9038       };
9039     }
9040   }
9041
9042   jresult = (void *)result;
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9048   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9049   uint16_t arg2 ;
9050
9051   arg1 = (Dali::Uint16Pair *)jarg1;
9052   arg2 = (uint16_t)jarg2;
9053   {
9054     try {
9055       (arg1)->SetWidth(arg2);
9056     } catch (std::out_of_range& e) {
9057       {
9058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9059       };
9060     } catch (std::exception& e) {
9061       {
9062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9063       };
9064     } catch (Dali::DaliException e) {
9065       {
9066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9071       };
9072     }
9073   }
9074
9075 }
9076
9077
9078 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9079   unsigned short jresult ;
9080   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9081   uint16_t result;
9082
9083   arg1 = (Dali::Uint16Pair *)jarg1;
9084   {
9085     try {
9086       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9087     } catch (std::out_of_range& e) {
9088       {
9089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9090       };
9091     } catch (std::exception& e) {
9092       {
9093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9094       };
9095     } catch (Dali::DaliException e) {
9096       {
9097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9098       };
9099     } catch (...) {
9100       {
9101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9102       };
9103     }
9104   }
9105
9106   jresult = result;
9107   return jresult;
9108 }
9109
9110
9111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9112   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9113   uint16_t arg2 ;
9114
9115   arg1 = (Dali::Uint16Pair *)jarg1;
9116   arg2 = (uint16_t)jarg2;
9117   {
9118     try {
9119       (arg1)->SetHeight(arg2);
9120     } catch (std::out_of_range& e) {
9121       {
9122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9123       };
9124     } catch (std::exception& e) {
9125       {
9126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9127       };
9128     } catch (Dali::DaliException e) {
9129       {
9130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9131       };
9132     } catch (...) {
9133       {
9134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9135       };
9136     }
9137   }
9138
9139 }
9140
9141
9142 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9143   unsigned short jresult ;
9144   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9145   uint16_t result;
9146
9147   arg1 = (Dali::Uint16Pair *)jarg1;
9148   {
9149     try {
9150       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9151     } catch (std::out_of_range& e) {
9152       {
9153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9154       };
9155     } catch (std::exception& e) {
9156       {
9157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9158       };
9159     } catch (Dali::DaliException e) {
9160       {
9161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9162       };
9163     } catch (...) {
9164       {
9165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9166       };
9167     }
9168   }
9169
9170   jresult = result;
9171   return jresult;
9172 }
9173
9174
9175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9176   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9177   uint16_t arg2 ;
9178
9179   arg1 = (Dali::Uint16Pair *)jarg1;
9180   arg2 = (uint16_t)jarg2;
9181   {
9182     try {
9183       (arg1)->SetX(arg2);
9184     } catch (std::out_of_range& e) {
9185       {
9186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9187       };
9188     } catch (std::exception& e) {
9189       {
9190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9191       };
9192     } catch (Dali::DaliException e) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9195       };
9196     } catch (...) {
9197       {
9198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9199       };
9200     }
9201   }
9202
9203 }
9204
9205
9206 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9207   unsigned short jresult ;
9208   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9209   uint16_t result;
9210
9211   arg1 = (Dali::Uint16Pair *)jarg1;
9212   {
9213     try {
9214       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9215     } catch (std::out_of_range& e) {
9216       {
9217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9218       };
9219     } catch (std::exception& e) {
9220       {
9221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9222       };
9223     } catch (Dali::DaliException e) {
9224       {
9225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9230       };
9231     }
9232   }
9233
9234   jresult = result;
9235   return jresult;
9236 }
9237
9238
9239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9240   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9241   uint16_t arg2 ;
9242
9243   arg1 = (Dali::Uint16Pair *)jarg1;
9244   arg2 = (uint16_t)jarg2;
9245   {
9246     try {
9247       (arg1)->SetY(arg2);
9248     } catch (std::out_of_range& e) {
9249       {
9250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9251       };
9252     } catch (std::exception& e) {
9253       {
9254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9255       };
9256     } catch (Dali::DaliException e) {
9257       {
9258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9259       };
9260     } catch (...) {
9261       {
9262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9263       };
9264     }
9265   }
9266
9267 }
9268
9269
9270 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9271   unsigned short jresult ;
9272   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9273   uint16_t result;
9274
9275   arg1 = (Dali::Uint16Pair *)jarg1;
9276   {
9277     try {
9278       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9279     } catch (std::out_of_range& e) {
9280       {
9281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9282       };
9283     } catch (std::exception& e) {
9284       {
9285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9286       };
9287     } catch (Dali::DaliException e) {
9288       {
9289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9290       };
9291     } catch (...) {
9292       {
9293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9294       };
9295     }
9296   }
9297
9298   jresult = result;
9299   return jresult;
9300 }
9301
9302
9303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9304   void * jresult ;
9305   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9306   Dali::Uint16Pair *arg2 = 0 ;
9307   Dali::Uint16Pair *result = 0 ;
9308
9309   arg1 = (Dali::Uint16Pair *)jarg1;
9310   arg2 = (Dali::Uint16Pair *)jarg2;
9311   if (!arg2) {
9312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9313     return 0;
9314   }
9315   {
9316     try {
9317       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9318     } catch (std::out_of_range& e) {
9319       {
9320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9321       };
9322     } catch (std::exception& e) {
9323       {
9324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9325       };
9326     } catch (Dali::DaliException e) {
9327       {
9328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9329       };
9330     } catch (...) {
9331       {
9332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9333       };
9334     }
9335   }
9336
9337   jresult = (void *)result;
9338   return jresult;
9339 }
9340
9341
9342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9343   unsigned int jresult ;
9344   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9345   Dali::Uint16Pair *arg2 = 0 ;
9346   bool result;
9347
9348   arg1 = (Dali::Uint16Pair *)jarg1;
9349   arg2 = (Dali::Uint16Pair *)jarg2;
9350   if (!arg2) {
9351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9352     return 0;
9353   }
9354   {
9355     try {
9356       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9357     } catch (std::out_of_range& e) {
9358       {
9359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9360       };
9361     } catch (std::exception& e) {
9362       {
9363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9364       };
9365     } catch (Dali::DaliException e) {
9366       {
9367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9368       };
9369     } catch (...) {
9370       {
9371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9372       };
9373     }
9374   }
9375
9376   jresult = result;
9377   return jresult;
9378 }
9379
9380
9381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9382   unsigned int jresult ;
9383   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9384   Dali::Uint16Pair *arg2 = 0 ;
9385   bool result;
9386
9387   arg1 = (Dali::Uint16Pair *)jarg1;
9388   arg2 = (Dali::Uint16Pair *)jarg2;
9389   if (!arg2) {
9390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9391     return 0;
9392   }
9393   {
9394     try {
9395       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9396     } catch (std::out_of_range& e) {
9397       {
9398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9399       };
9400     } catch (std::exception& e) {
9401       {
9402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9403       };
9404     } catch (Dali::DaliException e) {
9405       {
9406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9407       };
9408     } catch (...) {
9409       {
9410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9411       };
9412     }
9413   }
9414
9415   jresult = result;
9416   return jresult;
9417 }
9418
9419
9420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9421   unsigned int jresult ;
9422   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9423   Dali::Uint16Pair *arg2 = 0 ;
9424   bool result;
9425
9426   arg1 = (Dali::Uint16Pair *)jarg1;
9427   arg2 = (Dali::Uint16Pair *)jarg2;
9428   if (!arg2) {
9429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9430     return 0;
9431   }
9432   {
9433     try {
9434       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9435     } catch (std::out_of_range& e) {
9436       {
9437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9438       };
9439     } catch (std::exception& e) {
9440       {
9441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (Dali::DaliException e) {
9444       {
9445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9446       };
9447     } catch (...) {
9448       {
9449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9450       };
9451     }
9452   }
9453
9454   jresult = result;
9455   return jresult;
9456 }
9457
9458
9459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9460   unsigned int jresult ;
9461   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9462   Dali::Uint16Pair *arg2 = 0 ;
9463   bool result;
9464
9465   arg1 = (Dali::Uint16Pair *)jarg1;
9466   arg2 = (Dali::Uint16Pair *)jarg2;
9467   if (!arg2) {
9468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9469     return 0;
9470   }
9471   {
9472     try {
9473       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (Dali::DaliException e) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9485       };
9486     } catch (...) {
9487       {
9488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9489       };
9490     }
9491   }
9492
9493   jresult = result;
9494   return jresult;
9495 }
9496
9497
9498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9499   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9500
9501   arg1 = (Dali::Uint16Pair *)jarg1;
9502   {
9503     try {
9504       delete arg1;
9505     } catch (std::out_of_range& e) {
9506       {
9507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9508       };
9509     } catch (std::exception& e) {
9510       {
9511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9512       };
9513     } catch (Dali::DaliException e) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9516       };
9517     } catch (...) {
9518       {
9519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9520       };
9521     }
9522   }
9523
9524 }
9525
9526
9527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9528   void * jresult ;
9529   Dali::Degree *result = 0 ;
9530
9531   {
9532     try {
9533       result = (Dali::Degree *)new Dali::Degree();
9534     } catch (std::out_of_range& e) {
9535       {
9536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9537       };
9538     } catch (std::exception& e) {
9539       {
9540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9541       };
9542     } catch (Dali::DaliException e) {
9543       {
9544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9545       };
9546     } catch (...) {
9547       {
9548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9549       };
9550     }
9551   }
9552
9553   jresult = (void *)result;
9554   return jresult;
9555 }
9556
9557
9558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9559   void * jresult ;
9560   float arg1 ;
9561   Dali::Degree *result = 0 ;
9562
9563   arg1 = (float)jarg1;
9564   {
9565     try {
9566       result = (Dali::Degree *)new Dali::Degree(arg1);
9567     } catch (std::out_of_range& e) {
9568       {
9569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9570       };
9571     } catch (std::exception& e) {
9572       {
9573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9574       };
9575     } catch (Dali::DaliException e) {
9576       {
9577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9578       };
9579     } catch (...) {
9580       {
9581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9582       };
9583     }
9584   }
9585
9586   jresult = (void *)result;
9587   return jresult;
9588 }
9589
9590
9591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9592   void * jresult ;
9593   Dali::Radian arg1 ;
9594   Dali::Radian *argp1 ;
9595   Dali::Degree *result = 0 ;
9596
9597   argp1 = (Dali::Radian *)jarg1;
9598   if (!argp1) {
9599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9600     return 0;
9601   }
9602   arg1 = *argp1;
9603   {
9604     try {
9605       result = (Dali::Degree *)new Dali::Degree(arg1);
9606     } catch (std::out_of_range& e) {
9607       {
9608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9609       };
9610     } catch (std::exception& e) {
9611       {
9612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9613       };
9614     } catch (Dali::DaliException e) {
9615       {
9616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9617       };
9618     } catch (...) {
9619       {
9620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9621       };
9622     }
9623   }
9624
9625   jresult = (void *)result;
9626   return jresult;
9627 }
9628
9629
9630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9631   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9632   float arg2 ;
9633
9634   arg1 = (Dali::Degree *)jarg1;
9635   arg2 = (float)jarg2;
9636   if (arg1) (arg1)->degree = arg2;
9637 }
9638
9639
9640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9641   float jresult ;
9642   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9643   float result;
9644
9645   arg1 = (Dali::Degree *)jarg1;
9646   result = (float) ((arg1)->degree);
9647   jresult = result;
9648   return jresult;
9649 }
9650
9651
9652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9653   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9654
9655   arg1 = (Dali::Degree *)jarg1;
9656   {
9657     try {
9658       delete arg1;
9659     } catch (std::out_of_range& e) {
9660       {
9661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9662       };
9663     } catch (std::exception& e) {
9664       {
9665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9666       };
9667     } catch (Dali::DaliException e) {
9668       {
9669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9670       };
9671     } catch (...) {
9672       {
9673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9674       };
9675     }
9676   }
9677
9678 }
9679
9680
9681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9682   void * jresult ;
9683   Dali::Radian *result = 0 ;
9684
9685   result = (Dali::Radian *)&Dali::ANGLE_360;
9686   jresult = (void *)result;
9687   return jresult;
9688 }
9689
9690
9691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9692   void * jresult ;
9693   Dali::Radian *result = 0 ;
9694
9695   result = (Dali::Radian *)&Dali::ANGLE_315;
9696   jresult = (void *)result;
9697   return jresult;
9698 }
9699
9700
9701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9702   void * jresult ;
9703   Dali::Radian *result = 0 ;
9704
9705   result = (Dali::Radian *)&Dali::ANGLE_270;
9706   jresult = (void *)result;
9707   return jresult;
9708 }
9709
9710
9711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9712   void * jresult ;
9713   Dali::Radian *result = 0 ;
9714
9715   result = (Dali::Radian *)&Dali::ANGLE_225;
9716   jresult = (void *)result;
9717   return jresult;
9718 }
9719
9720
9721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9722   void * jresult ;
9723   Dali::Radian *result = 0 ;
9724
9725   result = (Dali::Radian *)&Dali::ANGLE_180;
9726   jresult = (void *)result;
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9732   void * jresult ;
9733   Dali::Radian *result = 0 ;
9734
9735   result = (Dali::Radian *)&Dali::ANGLE_135;
9736   jresult = (void *)result;
9737   return jresult;
9738 }
9739
9740
9741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9742   void * jresult ;
9743   Dali::Radian *result = 0 ;
9744
9745   result = (Dali::Radian *)&Dali::ANGLE_120;
9746   jresult = (void *)result;
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9752   void * jresult ;
9753   Dali::Radian *result = 0 ;
9754
9755   result = (Dali::Radian *)&Dali::ANGLE_90;
9756   jresult = (void *)result;
9757   return jresult;
9758 }
9759
9760
9761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9762   void * jresult ;
9763   Dali::Radian *result = 0 ;
9764
9765   result = (Dali::Radian *)&Dali::ANGLE_60;
9766   jresult = (void *)result;
9767   return jresult;
9768 }
9769
9770
9771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9772   void * jresult ;
9773   Dali::Radian *result = 0 ;
9774
9775   result = (Dali::Radian *)&Dali::ANGLE_45;
9776   jresult = (void *)result;
9777   return jresult;
9778 }
9779
9780
9781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9782   void * jresult ;
9783   Dali::Radian *result = 0 ;
9784
9785   result = (Dali::Radian *)&Dali::ANGLE_30;
9786   jresult = (void *)result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9792   void * jresult ;
9793   Dali::Radian *result = 0 ;
9794
9795   result = (Dali::Radian *)&Dali::ANGLE_0;
9796   jresult = (void *)result;
9797   return jresult;
9798 }
9799
9800
9801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9802   unsigned int jresult ;
9803   Dali::Degree *arg1 = 0 ;
9804   Dali::Degree *arg2 = 0 ;
9805   bool result;
9806
9807   arg1 = (Dali::Degree *)jarg1;
9808   if (!arg1) {
9809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9810     return 0;
9811   }
9812   arg2 = (Dali::Degree *)jarg2;
9813   if (!arg2) {
9814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9815     return 0;
9816   }
9817   {
9818     try {
9819       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9820     } catch (std::out_of_range& e) {
9821       {
9822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9823       };
9824     } catch (std::exception& e) {
9825       {
9826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9827       };
9828     } catch (Dali::DaliException e) {
9829       {
9830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9831       };
9832     } catch (...) {
9833       {
9834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9835       };
9836     }
9837   }
9838
9839   jresult = result;
9840   return jresult;
9841 }
9842
9843
9844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9845   unsigned int jresult ;
9846   Dali::Degree *arg1 = 0 ;
9847   Dali::Degree *arg2 = 0 ;
9848   bool result;
9849
9850   arg1 = (Dali::Degree *)jarg1;
9851   if (!arg1) {
9852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9853     return 0;
9854   }
9855   arg2 = (Dali::Degree *)jarg2;
9856   if (!arg2) {
9857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9858     return 0;
9859   }
9860   {
9861     try {
9862       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9863     } catch (std::out_of_range& e) {
9864       {
9865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9866       };
9867     } catch (std::exception& e) {
9868       {
9869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9870       };
9871     } catch (Dali::DaliException e) {
9872       {
9873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9874       };
9875     } catch (...) {
9876       {
9877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9878       };
9879     }
9880   }
9881
9882   jresult = result;
9883   return jresult;
9884 }
9885
9886
9887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9888   void * jresult ;
9889   Dali::Degree arg1 ;
9890   float arg2 ;
9891   float arg3 ;
9892   Dali::Degree *argp1 ;
9893   Dali::Degree result;
9894
9895   argp1 = (Dali::Degree *)jarg1;
9896   if (!argp1) {
9897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9898     return 0;
9899   }
9900   arg1 = *argp1;
9901   arg2 = (float)jarg2;
9902   arg3 = (float)jarg3;
9903   {
9904     try {
9905       result = Dali::Clamp(arg1,arg2,arg3);
9906     } catch (std::out_of_range& e) {
9907       {
9908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (std::exception& e) {
9911       {
9912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9913       };
9914     } catch (Dali::DaliException e) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9917       };
9918     } catch (...) {
9919       {
9920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9921       };
9922     }
9923   }
9924
9925   jresult = new Dali::Degree((const Dali::Degree &)result);
9926   return jresult;
9927 }
9928
9929
9930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9931   void * jresult ;
9932   Dali::Radian *result = 0 ;
9933
9934   {
9935     try {
9936       result = (Dali::Radian *)new Dali::Radian();
9937     } catch (std::out_of_range& e) {
9938       {
9939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9940       };
9941     } catch (std::exception& e) {
9942       {
9943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9944       };
9945     } catch (Dali::DaliException e) {
9946       {
9947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9948       };
9949     } catch (...) {
9950       {
9951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9952       };
9953     }
9954   }
9955
9956   jresult = (void *)result;
9957   return jresult;
9958 }
9959
9960
9961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9962   void * jresult ;
9963   float arg1 ;
9964   Dali::Radian *result = 0 ;
9965
9966   arg1 = (float)jarg1;
9967   {
9968     try {
9969       result = (Dali::Radian *)new Dali::Radian(arg1);
9970     } catch (std::out_of_range& e) {
9971       {
9972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9973       };
9974     } catch (std::exception& e) {
9975       {
9976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (Dali::DaliException e) {
9979       {
9980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9981       };
9982     } catch (...) {
9983       {
9984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9985       };
9986     }
9987   }
9988
9989   jresult = (void *)result;
9990   return jresult;
9991 }
9992
9993
9994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9995   void * jresult ;
9996   Dali::Degree arg1 ;
9997   Dali::Degree *argp1 ;
9998   Dali::Radian *result = 0 ;
9999
10000   argp1 = (Dali::Degree *)jarg1;
10001   if (!argp1) {
10002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10003     return 0;
10004   }
10005   arg1 = *argp1;
10006   {
10007     try {
10008       result = (Dali::Radian *)new Dali::Radian(arg1);
10009     } catch (std::out_of_range& e) {
10010       {
10011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10012       };
10013     } catch (std::exception& e) {
10014       {
10015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (Dali::DaliException e) {
10018       {
10019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10020       };
10021     } catch (...) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10024       };
10025     }
10026   }
10027
10028   jresult = (void *)result;
10029   return jresult;
10030 }
10031
10032
10033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10034   void * jresult ;
10035   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10036   float arg2 ;
10037   Dali::Radian *result = 0 ;
10038
10039   arg1 = (Dali::Radian *)jarg1;
10040   arg2 = (float)jarg2;
10041   {
10042     try {
10043       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10044     } catch (std::out_of_range& e) {
10045       {
10046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10047       };
10048     } catch (std::exception& e) {
10049       {
10050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10051       };
10052     } catch (Dali::DaliException e) {
10053       {
10054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10055       };
10056     } catch (...) {
10057       {
10058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10059       };
10060     }
10061   }
10062
10063   jresult = (void *)result;
10064   return jresult;
10065 }
10066
10067
10068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10069   void * jresult ;
10070   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10071   Dali::Degree arg2 ;
10072   Dali::Degree *argp2 ;
10073   Dali::Radian *result = 0 ;
10074
10075   arg1 = (Dali::Radian *)jarg1;
10076   argp2 = (Dali::Degree *)jarg2;
10077   if (!argp2) {
10078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10079     return 0;
10080   }
10081   arg2 = *argp2;
10082   {
10083     try {
10084       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10085     } catch (std::out_of_range& e) {
10086       {
10087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (std::exception& e) {
10090       {
10091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10092       };
10093     } catch (Dali::DaliException e) {
10094       {
10095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10096       };
10097     } catch (...) {
10098       {
10099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10100       };
10101     }
10102   }
10103
10104   jresult = (void *)result;
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10110   float jresult ;
10111   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10112   float result;
10113
10114   arg1 = (Dali::Radian *)jarg1;
10115   {
10116     try {
10117       result = (float)((Dali::Radian const *)arg1)->operator float();
10118     } catch (std::out_of_range& e) {
10119       {
10120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (std::exception& e) {
10123       {
10124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10125       };
10126     } catch (Dali::DaliException e) {
10127       {
10128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10129       };
10130     } catch (...) {
10131       {
10132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10133       };
10134     }
10135   }
10136
10137   jresult = result;
10138   return jresult;
10139 }
10140
10141
10142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10143   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10144   float arg2 ;
10145
10146   arg1 = (Dali::Radian *)jarg1;
10147   arg2 = (float)jarg2;
10148   if (arg1) (arg1)->radian = arg2;
10149 }
10150
10151
10152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10153   float jresult ;
10154   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10155   float result;
10156
10157   arg1 = (Dali::Radian *)jarg1;
10158   result = (float) ((arg1)->radian);
10159   jresult = result;
10160   return jresult;
10161 }
10162
10163
10164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10165   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10166
10167   arg1 = (Dali::Radian *)jarg1;
10168   {
10169     try {
10170       delete arg1;
10171     } catch (std::out_of_range& e) {
10172       {
10173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10174       };
10175     } catch (std::exception& e) {
10176       {
10177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10178       };
10179     } catch (Dali::DaliException e) {
10180       {
10181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10182       };
10183     } catch (...) {
10184       {
10185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10186       };
10187     }
10188   }
10189
10190 }
10191
10192
10193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10194   unsigned int jresult ;
10195   Dali::Radian arg1 ;
10196   Dali::Radian arg2 ;
10197   Dali::Radian *argp1 ;
10198   Dali::Radian *argp2 ;
10199   bool result;
10200
10201   argp1 = (Dali::Radian *)jarg1;
10202   if (!argp1) {
10203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10204     return 0;
10205   }
10206   arg1 = *argp1;
10207   argp2 = (Dali::Radian *)jarg2;
10208   if (!argp2) {
10209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10210     return 0;
10211   }
10212   arg2 = *argp2;
10213   {
10214     try {
10215       result = (bool)Dali::operator ==(arg1,arg2);
10216     } catch (std::out_of_range& e) {
10217       {
10218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10219       };
10220     } catch (std::exception& e) {
10221       {
10222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10223       };
10224     } catch (Dali::DaliException e) {
10225       {
10226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10227       };
10228     } catch (...) {
10229       {
10230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10231       };
10232     }
10233   }
10234
10235   jresult = result;
10236   return jresult;
10237 }
10238
10239
10240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10241   unsigned int jresult ;
10242   Dali::Radian arg1 ;
10243   Dali::Radian arg2 ;
10244   Dali::Radian *argp1 ;
10245   Dali::Radian *argp2 ;
10246   bool result;
10247
10248   argp1 = (Dali::Radian *)jarg1;
10249   if (!argp1) {
10250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10251     return 0;
10252   }
10253   arg1 = *argp1;
10254   argp2 = (Dali::Radian *)jarg2;
10255   if (!argp2) {
10256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10257     return 0;
10258   }
10259   arg2 = *argp2;
10260   {
10261     try {
10262       result = (bool)Dali::operator !=(arg1,arg2);
10263     } catch (std::out_of_range& e) {
10264       {
10265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10266       };
10267     } catch (std::exception& e) {
10268       {
10269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10270       };
10271     } catch (Dali::DaliException e) {
10272       {
10273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10274       };
10275     } catch (...) {
10276       {
10277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10278       };
10279     }
10280   }
10281
10282   jresult = result;
10283   return jresult;
10284 }
10285
10286
10287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10288   unsigned int jresult ;
10289   Dali::Radian arg1 ;
10290   Dali::Degree arg2 ;
10291   Dali::Radian *argp1 ;
10292   Dali::Degree *argp2 ;
10293   bool result;
10294
10295   argp1 = (Dali::Radian *)jarg1;
10296   if (!argp1) {
10297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10298     return 0;
10299   }
10300   arg1 = *argp1;
10301   argp2 = (Dali::Degree *)jarg2;
10302   if (!argp2) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10304     return 0;
10305   }
10306   arg2 = *argp2;
10307   {
10308     try {
10309       result = (bool)Dali::operator ==(arg1,arg2);
10310     } catch (std::out_of_range& e) {
10311       {
10312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10313       };
10314     } catch (std::exception& e) {
10315       {
10316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10317       };
10318     } catch (Dali::DaliException e) {
10319       {
10320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10321       };
10322     } catch (...) {
10323       {
10324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10325       };
10326     }
10327   }
10328
10329   jresult = result;
10330   return jresult;
10331 }
10332
10333
10334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10335   unsigned int jresult ;
10336   Dali::Radian arg1 ;
10337   Dali::Degree arg2 ;
10338   Dali::Radian *argp1 ;
10339   Dali::Degree *argp2 ;
10340   bool result;
10341
10342   argp1 = (Dali::Radian *)jarg1;
10343   if (!argp1) {
10344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10345     return 0;
10346   }
10347   arg1 = *argp1;
10348   argp2 = (Dali::Degree *)jarg2;
10349   if (!argp2) {
10350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10351     return 0;
10352   }
10353   arg2 = *argp2;
10354   {
10355     try {
10356       result = (bool)Dali::operator !=(arg1,arg2);
10357     } catch (std::out_of_range& e) {
10358       {
10359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (std::exception& e) {
10362       {
10363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10364       };
10365     } catch (Dali::DaliException e) {
10366       {
10367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10368       };
10369     } catch (...) {
10370       {
10371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10372       };
10373     }
10374   }
10375
10376   jresult = result;
10377   return jresult;
10378 }
10379
10380
10381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10382   unsigned int jresult ;
10383   Dali::Degree arg1 ;
10384   Dali::Radian arg2 ;
10385   Dali::Degree *argp1 ;
10386   Dali::Radian *argp2 ;
10387   bool result;
10388
10389   argp1 = (Dali::Degree *)jarg1;
10390   if (!argp1) {
10391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10392     return 0;
10393   }
10394   arg1 = *argp1;
10395   argp2 = (Dali::Radian *)jarg2;
10396   if (!argp2) {
10397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10398     return 0;
10399   }
10400   arg2 = *argp2;
10401   {
10402     try {
10403       result = (bool)Dali::operator ==(arg1,arg2);
10404     } catch (std::out_of_range& e) {
10405       {
10406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10407       };
10408     } catch (std::exception& e) {
10409       {
10410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10411       };
10412     } catch (Dali::DaliException e) {
10413       {
10414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10415       };
10416     } catch (...) {
10417       {
10418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10419       };
10420     }
10421   }
10422
10423   jresult = result;
10424   return jresult;
10425 }
10426
10427
10428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10429   unsigned int jresult ;
10430   Dali::Degree arg1 ;
10431   Dali::Radian arg2 ;
10432   Dali::Degree *argp1 ;
10433   Dali::Radian *argp2 ;
10434   bool result;
10435
10436   argp1 = (Dali::Degree *)jarg1;
10437   if (!argp1) {
10438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10439     return 0;
10440   }
10441   arg1 = *argp1;
10442   argp2 = (Dali::Radian *)jarg2;
10443   if (!argp2) {
10444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10445     return 0;
10446   }
10447   arg2 = *argp2;
10448   {
10449     try {
10450       result = (bool)Dali::operator !=(arg1,arg2);
10451     } catch (std::out_of_range& e) {
10452       {
10453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10454       };
10455     } catch (std::exception& e) {
10456       {
10457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10458       };
10459     } catch (Dali::DaliException e) {
10460       {
10461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10462       };
10463     } catch (...) {
10464       {
10465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10466       };
10467     }
10468   }
10469
10470   jresult = result;
10471   return jresult;
10472 }
10473
10474
10475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10476   unsigned int jresult ;
10477   Dali::Radian arg1 ;
10478   Dali::Radian arg2 ;
10479   Dali::Radian *argp1 ;
10480   Dali::Radian *argp2 ;
10481   bool result;
10482
10483   argp1 = (Dali::Radian *)jarg1;
10484   if (!argp1) {
10485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10486     return 0;
10487   }
10488   arg1 = *argp1;
10489   argp2 = (Dali::Radian *)jarg2;
10490   if (!argp2) {
10491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10492     return 0;
10493   }
10494   arg2 = *argp2;
10495   {
10496     try {
10497       result = (bool)Dali::operator >(arg1,arg2);
10498     } catch (std::out_of_range& e) {
10499       {
10500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10501       };
10502     } catch (std::exception& e) {
10503       {
10504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10505       };
10506     } catch (Dali::DaliException e) {
10507       {
10508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10509       };
10510     } catch (...) {
10511       {
10512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10513       };
10514     }
10515   }
10516
10517   jresult = result;
10518   return jresult;
10519 }
10520
10521
10522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10523   unsigned int jresult ;
10524   Dali::Radian arg1 ;
10525   Dali::Degree arg2 ;
10526   Dali::Radian *argp1 ;
10527   Dali::Degree *argp2 ;
10528   bool result;
10529
10530   argp1 = (Dali::Radian *)jarg1;
10531   if (!argp1) {
10532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10533     return 0;
10534   }
10535   arg1 = *argp1;
10536   argp2 = (Dali::Degree *)jarg2;
10537   if (!argp2) {
10538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10539     return 0;
10540   }
10541   arg2 = *argp2;
10542   {
10543     try {
10544       result = (bool)Dali::operator >(arg1,arg2);
10545     } catch (std::out_of_range& e) {
10546       {
10547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10548       };
10549     } catch (std::exception& e) {
10550       {
10551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10552       };
10553     } catch (Dali::DaliException e) {
10554       {
10555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10556       };
10557     } catch (...) {
10558       {
10559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10560       };
10561     }
10562   }
10563
10564   jresult = result;
10565   return jresult;
10566 }
10567
10568
10569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10570   unsigned int jresult ;
10571   Dali::Degree arg1 ;
10572   Dali::Radian arg2 ;
10573   Dali::Degree *argp1 ;
10574   Dali::Radian *argp2 ;
10575   bool result;
10576
10577   argp1 = (Dali::Degree *)jarg1;
10578   if (!argp1) {
10579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10580     return 0;
10581   }
10582   arg1 = *argp1;
10583   argp2 = (Dali::Radian *)jarg2;
10584   if (!argp2) {
10585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10586     return 0;
10587   }
10588   arg2 = *argp2;
10589   {
10590     try {
10591       result = (bool)Dali::operator >(arg1,arg2);
10592     } catch (std::out_of_range& e) {
10593       {
10594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10595       };
10596     } catch (std::exception& e) {
10597       {
10598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10599       };
10600     } catch (Dali::DaliException e) {
10601       {
10602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10603       };
10604     } catch (...) {
10605       {
10606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10607       };
10608     }
10609   }
10610
10611   jresult = result;
10612   return jresult;
10613 }
10614
10615
10616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10617   unsigned int jresult ;
10618   Dali::Radian arg1 ;
10619   Dali::Radian arg2 ;
10620   Dali::Radian *argp1 ;
10621   Dali::Radian *argp2 ;
10622   bool result;
10623
10624   argp1 = (Dali::Radian *)jarg1;
10625   if (!argp1) {
10626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10627     return 0;
10628   }
10629   arg1 = *argp1;
10630   argp2 = (Dali::Radian *)jarg2;
10631   if (!argp2) {
10632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10633     return 0;
10634   }
10635   arg2 = *argp2;
10636   {
10637     try {
10638       result = (bool)Dali::operator <(arg1,arg2);
10639     } catch (std::out_of_range& e) {
10640       {
10641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10642       };
10643     } catch (std::exception& e) {
10644       {
10645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10646       };
10647     } catch (Dali::DaliException e) {
10648       {
10649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10650       };
10651     } catch (...) {
10652       {
10653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10654       };
10655     }
10656   }
10657
10658   jresult = result;
10659   return jresult;
10660 }
10661
10662
10663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10664   unsigned int jresult ;
10665   Dali::Radian arg1 ;
10666   Dali::Degree arg2 ;
10667   Dali::Radian *argp1 ;
10668   Dali::Degree *argp2 ;
10669   bool result;
10670
10671   argp1 = (Dali::Radian *)jarg1;
10672   if (!argp1) {
10673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10674     return 0;
10675   }
10676   arg1 = *argp1;
10677   argp2 = (Dali::Degree *)jarg2;
10678   if (!argp2) {
10679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10680     return 0;
10681   }
10682   arg2 = *argp2;
10683   {
10684     try {
10685       result = (bool)Dali::operator <(arg1,arg2);
10686     } catch (std::out_of_range& e) {
10687       {
10688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10689       };
10690     } catch (std::exception& e) {
10691       {
10692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10693       };
10694     } catch (Dali::DaliException e) {
10695       {
10696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10697       };
10698     } catch (...) {
10699       {
10700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10701       };
10702     }
10703   }
10704
10705   jresult = result;
10706   return jresult;
10707 }
10708
10709
10710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10711   unsigned int jresult ;
10712   Dali::Degree arg1 ;
10713   Dali::Radian arg2 ;
10714   Dali::Degree *argp1 ;
10715   Dali::Radian *argp2 ;
10716   bool result;
10717
10718   argp1 = (Dali::Degree *)jarg1;
10719   if (!argp1) {
10720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10721     return 0;
10722   }
10723   arg1 = *argp1;
10724   argp2 = (Dali::Radian *)jarg2;
10725   if (!argp2) {
10726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10727     return 0;
10728   }
10729   arg2 = *argp2;
10730   {
10731     try {
10732       result = (bool)Dali::operator <(arg1,arg2);
10733     } catch (std::out_of_range& e) {
10734       {
10735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10736       };
10737     } catch (std::exception& e) {
10738       {
10739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10740       };
10741     } catch (Dali::DaliException e) {
10742       {
10743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10744       };
10745     } catch (...) {
10746       {
10747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10748       };
10749     }
10750   }
10751
10752   jresult = result;
10753   return jresult;
10754 }
10755
10756
10757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10758   void * jresult ;
10759   Dali::Radian arg1 ;
10760   float arg2 ;
10761   Dali::Radian *argp1 ;
10762   Dali::Radian result;
10763
10764   argp1 = (Dali::Radian *)jarg1;
10765   if (!argp1) {
10766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10767     return 0;
10768   }
10769   arg1 = *argp1;
10770   arg2 = (float)jarg2;
10771   {
10772     try {
10773       result = Dali::operator *(arg1,arg2);
10774     } catch (std::out_of_range& e) {
10775       {
10776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10777       };
10778     } catch (std::exception& e) {
10779       {
10780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10781       };
10782     } catch (Dali::DaliException e) {
10783       {
10784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10785       };
10786     } catch (...) {
10787       {
10788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10789       };
10790     }
10791   }
10792
10793   jresult = new Dali::Radian((const Dali::Radian &)result);
10794   return jresult;
10795 }
10796
10797
10798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10799   void * jresult ;
10800   Dali::Radian arg1 ;
10801   Dali::Radian *argp1 ;
10802   Dali::Radian result;
10803
10804   argp1 = (Dali::Radian *)jarg1;
10805   if (!argp1) {
10806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10807     return 0;
10808   }
10809   arg1 = *argp1;
10810   {
10811     try {
10812       result = Dali::operator -(arg1);
10813     } catch (std::out_of_range& e) {
10814       {
10815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10816       };
10817     } catch (std::exception& e) {
10818       {
10819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10820       };
10821     } catch (Dali::DaliException e) {
10822       {
10823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10824       };
10825     } catch (...) {
10826       {
10827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10828       };
10829     }
10830   }
10831
10832   jresult = new Dali::Radian((const Dali::Radian &)result);
10833   return jresult;
10834 }
10835
10836
10837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10838   void * jresult ;
10839   Dali::Radian arg1 ;
10840   float arg2 ;
10841   float arg3 ;
10842   Dali::Radian *argp1 ;
10843   Dali::Radian result;
10844
10845   argp1 = (Dali::Radian *)jarg1;
10846   if (!argp1) {
10847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10848     return 0;
10849   }
10850   arg1 = *argp1;
10851   arg2 = (float)jarg2;
10852   arg3 = (float)jarg3;
10853   {
10854     try {
10855       result = Dali::Clamp(arg1,arg2,arg3);
10856     } catch (std::out_of_range& e) {
10857       {
10858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (std::exception& e) {
10861       {
10862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10863       };
10864     } catch (Dali::DaliException e) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10867       };
10868     } catch (...) {
10869       {
10870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10871       };
10872     }
10873   }
10874
10875   jresult = new Dali::Radian((const Dali::Radian &)result);
10876   return jresult;
10877 }
10878
10879
10880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10881   void * jresult ;
10882   Dali::Quaternion *result = 0 ;
10883
10884   {
10885     try {
10886       result = (Dali::Quaternion *)new Dali::Quaternion();
10887     } catch (std::out_of_range& e) {
10888       {
10889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10890       };
10891     } catch (std::exception& e) {
10892       {
10893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10894       };
10895     } catch (Dali::DaliException e) {
10896       {
10897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10898       };
10899     } catch (...) {
10900       {
10901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10902       };
10903     }
10904   }
10905
10906   jresult = (void *)result;
10907   return jresult;
10908 }
10909
10910
10911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10912   void * jresult ;
10913   Dali::Radian arg1 ;
10914   Dali::Vector3 *arg2 = 0 ;
10915   Dali::Radian *argp1 ;
10916   Dali::Quaternion *result = 0 ;
10917
10918   argp1 = (Dali::Radian *)jarg1;
10919   if (!argp1) {
10920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10921     return 0;
10922   }
10923   arg1 = *argp1;
10924   arg2 = (Dali::Vector3 *)jarg2;
10925   if (!arg2) {
10926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10927     return 0;
10928   }
10929   {
10930     try {
10931       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10932     } catch (std::out_of_range& e) {
10933       {
10934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10935       };
10936     } catch (std::exception& e) {
10937       {
10938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10939       };
10940     } catch (Dali::DaliException e) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10943       };
10944     } catch (...) {
10945       {
10946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10947       };
10948     }
10949   }
10950
10951   jresult = (void *)result;
10952   return jresult;
10953 }
10954
10955
10956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10957   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10958
10959   arg1 = (Dali::Quaternion *)jarg1;
10960   {
10961     try {
10962       delete arg1;
10963     } catch (std::out_of_range& e) {
10964       {
10965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10966       };
10967     } catch (std::exception& e) {
10968       {
10969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10970       };
10971     } catch (Dali::DaliException e) {
10972       {
10973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10974       };
10975     } catch (...) {
10976       {
10977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10978       };
10979     }
10980   }
10981
10982 }
10983
10984
10985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10986   void * jresult ;
10987   Dali::Quaternion *result = 0 ;
10988
10989   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10990   jresult = (void *)result;
10991   return jresult;
10992 }
10993
10994
10995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10996   unsigned int jresult ;
10997   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10998   bool result;
10999
11000   arg1 = (Dali::Quaternion *)jarg1;
11001   {
11002     try {
11003       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11004     } catch (std::out_of_range& e) {
11005       {
11006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11007       };
11008     } catch (std::exception& e) {
11009       {
11010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11011       };
11012     } catch (Dali::DaliException e) {
11013       {
11014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11015       };
11016     } catch (...) {
11017       {
11018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11019       };
11020     }
11021   }
11022
11023   jresult = result;
11024   return jresult;
11025 }
11026
11027
11028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11029   unsigned int jresult ;
11030   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11031   Dali::Vector3 *arg2 = 0 ;
11032   Dali::Radian *arg3 = 0 ;
11033   bool result;
11034
11035   arg1 = (Dali::Quaternion *)jarg1;
11036   arg2 = (Dali::Vector3 *)jarg2;
11037   if (!arg2) {
11038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11039     return 0;
11040   }
11041   arg3 = (Dali::Radian *)jarg3;
11042   if (!arg3) {
11043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11044     return 0;
11045   }
11046   {
11047     try {
11048       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11049     } catch (std::out_of_range& e) {
11050       {
11051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11052       };
11053     } catch (std::exception& e) {
11054       {
11055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11056       };
11057     } catch (Dali::DaliException e) {
11058       {
11059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11060       };
11061     } catch (...) {
11062       {
11063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11064       };
11065     }
11066   }
11067
11068   jresult = result;
11069   return jresult;
11070 }
11071
11072
11073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11074   void * jresult ;
11075   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11076   Dali::Quaternion *arg2 = 0 ;
11077   Dali::Quaternion result;
11078
11079   arg1 = (Dali::Quaternion *)jarg1;
11080   arg2 = (Dali::Quaternion *)jarg2;
11081   if (!arg2) {
11082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11083     return 0;
11084   }
11085   {
11086     try {
11087       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11088     } catch (std::out_of_range& e) {
11089       {
11090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11091       };
11092     } catch (std::exception& e) {
11093       {
11094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11095       };
11096     } catch (Dali::DaliException e) {
11097       {
11098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11099       };
11100     } catch (...) {
11101       {
11102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11103       };
11104     }
11105   }
11106
11107   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11108   return jresult;
11109 }
11110
11111
11112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11113   void * jresult ;
11114   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11115   Dali::Quaternion *arg2 = 0 ;
11116   Dali::Quaternion result;
11117
11118   arg1 = (Dali::Quaternion *)jarg1;
11119   arg2 = (Dali::Quaternion *)jarg2;
11120   if (!arg2) {
11121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11122     return 0;
11123   }
11124   {
11125     try {
11126       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11127     } catch (std::out_of_range& e) {
11128       {
11129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11130       };
11131     } catch (std::exception& e) {
11132       {
11133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11134       };
11135     } catch (Dali::DaliException e) {
11136       {
11137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11138       };
11139     } catch (...) {
11140       {
11141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11142       };
11143     }
11144   }
11145
11146   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11147   return jresult;
11148 }
11149
11150
11151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11152   void * jresult ;
11153   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11154   Dali::Quaternion *arg2 = 0 ;
11155   Dali::Quaternion result;
11156
11157   arg1 = (Dali::Quaternion *)jarg1;
11158   arg2 = (Dali::Quaternion *)jarg2;
11159   if (!arg2) {
11160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11161     return 0;
11162   }
11163   {
11164     try {
11165       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11166     } catch (std::out_of_range& e) {
11167       {
11168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11169       };
11170     } catch (std::exception& e) {
11171       {
11172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (Dali::DaliException e) {
11175       {
11176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184
11185   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11186   return jresult;
11187 }
11188
11189
11190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11191   void * jresult ;
11192   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11193   Dali::Vector3 *arg2 = 0 ;
11194   Dali::Vector3 result;
11195
11196   arg1 = (Dali::Quaternion *)jarg1;
11197   arg2 = (Dali::Vector3 *)jarg2;
11198   if (!arg2) {
11199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11200     return 0;
11201   }
11202   {
11203     try {
11204       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11205     } catch (std::out_of_range& e) {
11206       {
11207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11208       };
11209     } catch (std::exception& e) {
11210       {
11211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11212       };
11213     } catch (Dali::DaliException e) {
11214       {
11215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11216       };
11217     } catch (...) {
11218       {
11219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11220       };
11221     }
11222   }
11223
11224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11225   return jresult;
11226 }
11227
11228
11229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11230   void * jresult ;
11231   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11232   Dali::Quaternion *arg2 = 0 ;
11233   Dali::Quaternion result;
11234
11235   arg1 = (Dali::Quaternion *)jarg1;
11236   arg2 = (Dali::Quaternion *)jarg2;
11237   if (!arg2) {
11238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11239     return 0;
11240   }
11241   {
11242     try {
11243       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11244     } catch (std::out_of_range& e) {
11245       {
11246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11247       };
11248     } catch (std::exception& e) {
11249       {
11250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (Dali::DaliException e) {
11253       {
11254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11255       };
11256     } catch (...) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11259       };
11260     }
11261   }
11262
11263   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11264   return jresult;
11265 }
11266
11267
11268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11269   void * jresult ;
11270   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11271   float arg2 ;
11272   Dali::Quaternion result;
11273
11274   arg1 = (Dali::Quaternion *)jarg1;
11275   arg2 = (float)jarg2;
11276   {
11277     try {
11278       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11279     } catch (std::out_of_range& e) {
11280       {
11281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11282       };
11283     } catch (std::exception& e) {
11284       {
11285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11286       };
11287     } catch (Dali::DaliException e) {
11288       {
11289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11290       };
11291     } catch (...) {
11292       {
11293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11294       };
11295     }
11296   }
11297
11298   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11299   return jresult;
11300 }
11301
11302
11303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11304   void * jresult ;
11305   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11306   float arg2 ;
11307   Dali::Quaternion result;
11308
11309   arg1 = (Dali::Quaternion *)jarg1;
11310   arg2 = (float)jarg2;
11311   {
11312     try {
11313       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11314     } catch (std::out_of_range& e) {
11315       {
11316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11317       };
11318     } catch (std::exception& e) {
11319       {
11320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11321       };
11322     } catch (Dali::DaliException e) {
11323       {
11324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11325       };
11326     } catch (...) {
11327       {
11328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11329       };
11330     }
11331   }
11332
11333   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11334   return jresult;
11335 }
11336
11337
11338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11339   void * jresult ;
11340   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11341   Dali::Quaternion result;
11342
11343   arg1 = (Dali::Quaternion *)jarg1;
11344   {
11345     try {
11346       result = ((Dali::Quaternion const *)arg1)->operator -();
11347     } catch (std::out_of_range& e) {
11348       {
11349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11350       };
11351     } catch (std::exception& e) {
11352       {
11353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11354       };
11355     } catch (Dali::DaliException e) {
11356       {
11357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11358       };
11359     } catch (...) {
11360       {
11361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11362       };
11363     }
11364   }
11365
11366   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11367   return jresult;
11368 }
11369
11370
11371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11372   void * jresult ;
11373   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11374   Dali::Quaternion *arg2 = 0 ;
11375   Dali::Quaternion *result = 0 ;
11376
11377   arg1 = (Dali::Quaternion *)jarg1;
11378   arg2 = (Dali::Quaternion *)jarg2;
11379   if (!arg2) {
11380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11381     return 0;
11382   }
11383   {
11384     try {
11385       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11386     } catch (std::out_of_range& e) {
11387       {
11388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11389       };
11390     } catch (std::exception& e) {
11391       {
11392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11393       };
11394     } catch (Dali::DaliException e) {
11395       {
11396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11397       };
11398     } catch (...) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11401       };
11402     }
11403   }
11404
11405   jresult = (void *)result;
11406   return jresult;
11407 }
11408
11409
11410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11411   void * jresult ;
11412   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11413   Dali::Quaternion *arg2 = 0 ;
11414   Dali::Quaternion *result = 0 ;
11415
11416   arg1 = (Dali::Quaternion *)jarg1;
11417   arg2 = (Dali::Quaternion *)jarg2;
11418   if (!arg2) {
11419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11420     return 0;
11421   }
11422   {
11423     try {
11424       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11425     } catch (std::out_of_range& e) {
11426       {
11427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11428       };
11429     } catch (std::exception& e) {
11430       {
11431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11432       };
11433     } catch (Dali::DaliException e) {
11434       {
11435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11436       };
11437     } catch (...) {
11438       {
11439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11440       };
11441     }
11442   }
11443
11444   jresult = (void *)result;
11445   return jresult;
11446 }
11447
11448
11449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11450   void * jresult ;
11451   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11452   Dali::Quaternion *arg2 = 0 ;
11453   Dali::Quaternion *result = 0 ;
11454
11455   arg1 = (Dali::Quaternion *)jarg1;
11456   arg2 = (Dali::Quaternion *)jarg2;
11457   if (!arg2) {
11458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11459     return 0;
11460   }
11461   {
11462     try {
11463       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11464     } catch (std::out_of_range& e) {
11465       {
11466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11467       };
11468     } catch (std::exception& e) {
11469       {
11470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11471       };
11472     } catch (Dali::DaliException e) {
11473       {
11474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11475       };
11476     } catch (...) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11479       };
11480     }
11481   }
11482
11483   jresult = (void *)result;
11484   return jresult;
11485 }
11486
11487
11488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11489   void * jresult ;
11490   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11491   float arg2 ;
11492   Dali::Quaternion *result = 0 ;
11493
11494   arg1 = (Dali::Quaternion *)jarg1;
11495   arg2 = (float)jarg2;
11496   {
11497     try {
11498       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11499     } catch (std::out_of_range& e) {
11500       {
11501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11502       };
11503     } catch (std::exception& e) {
11504       {
11505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (Dali::DaliException e) {
11508       {
11509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11510       };
11511     } catch (...) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11514       };
11515     }
11516   }
11517
11518   jresult = (void *)result;
11519   return jresult;
11520 }
11521
11522
11523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11524   void * jresult ;
11525   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11526   float arg2 ;
11527   Dali::Quaternion *result = 0 ;
11528
11529   arg1 = (Dali::Quaternion *)jarg1;
11530   arg2 = (float)jarg2;
11531   {
11532     try {
11533       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11534     } catch (std::out_of_range& e) {
11535       {
11536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11537       };
11538     } catch (std::exception& e) {
11539       {
11540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11541       };
11542     } catch (Dali::DaliException e) {
11543       {
11544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11545       };
11546     } catch (...) {
11547       {
11548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11549       };
11550     }
11551   }
11552
11553   jresult = (void *)result;
11554   return jresult;
11555 }
11556
11557
11558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11559   unsigned int jresult ;
11560   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11561   Dali::Quaternion *arg2 = 0 ;
11562   bool result;
11563
11564   arg1 = (Dali::Quaternion *)jarg1;
11565   arg2 = (Dali::Quaternion *)jarg2;
11566   if (!arg2) {
11567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11568     return 0;
11569   }
11570   {
11571     try {
11572       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11573     } catch (std::out_of_range& e) {
11574       {
11575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11576       };
11577     } catch (std::exception& e) {
11578       {
11579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11580       };
11581     } catch (Dali::DaliException e) {
11582       {
11583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11584       };
11585     } catch (...) {
11586       {
11587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11588       };
11589     }
11590   }
11591
11592   jresult = result;
11593   return jresult;
11594 }
11595
11596
11597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11598   unsigned int jresult ;
11599   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11600   Dali::Quaternion *arg2 = 0 ;
11601   bool result;
11602
11603   arg1 = (Dali::Quaternion *)jarg1;
11604   arg2 = (Dali::Quaternion *)jarg2;
11605   if (!arg2) {
11606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11607     return 0;
11608   }
11609   {
11610     try {
11611       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11612     } catch (std::out_of_range& e) {
11613       {
11614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11615       };
11616     } catch (std::exception& e) {
11617       {
11618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11619       };
11620     } catch (Dali::DaliException e) {
11621       {
11622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11623       };
11624     } catch (...) {
11625       {
11626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11627       };
11628     }
11629   }
11630
11631   jresult = result;
11632   return jresult;
11633 }
11634
11635
11636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11637   float jresult ;
11638   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11639   float result;
11640
11641   arg1 = (Dali::Quaternion *)jarg1;
11642   {
11643     try {
11644       result = (float)((Dali::Quaternion const *)arg1)->Length();
11645     } catch (std::out_of_range& e) {
11646       {
11647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11648       };
11649     } catch (std::exception& e) {
11650       {
11651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11652       };
11653     } catch (Dali::DaliException e) {
11654       {
11655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11656       };
11657     } catch (...) {
11658       {
11659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11660       };
11661     }
11662   }
11663
11664   jresult = result;
11665   return jresult;
11666 }
11667
11668
11669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11670   float jresult ;
11671   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11672   float result;
11673
11674   arg1 = (Dali::Quaternion *)jarg1;
11675   {
11676     try {
11677       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11678     } catch (std::out_of_range& e) {
11679       {
11680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11681       };
11682     } catch (std::exception& e) {
11683       {
11684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11685       };
11686     } catch (Dali::DaliException e) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11689       };
11690     } catch (...) {
11691       {
11692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11693       };
11694     }
11695   }
11696
11697   jresult = result;
11698   return jresult;
11699 }
11700
11701
11702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11703   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11704
11705   arg1 = (Dali::Quaternion *)jarg1;
11706   {
11707     try {
11708       (arg1)->Normalize();
11709     } catch (std::out_of_range& e) {
11710       {
11711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11712       };
11713     } catch (std::exception& e) {
11714       {
11715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11716       };
11717     } catch (Dali::DaliException e) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11720       };
11721     } catch (...) {
11722       {
11723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11724       };
11725     }
11726   }
11727
11728 }
11729
11730
11731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11732   void * jresult ;
11733   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11734   Dali::Quaternion result;
11735
11736   arg1 = (Dali::Quaternion *)jarg1;
11737   {
11738     try {
11739       result = ((Dali::Quaternion const *)arg1)->Normalized();
11740     } catch (std::out_of_range& e) {
11741       {
11742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11743       };
11744     } catch (std::exception& e) {
11745       {
11746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11747       };
11748     } catch (Dali::DaliException e) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11755       };
11756     }
11757   }
11758
11759   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11760   return jresult;
11761 }
11762
11763
11764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11765   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11766
11767   arg1 = (Dali::Quaternion *)jarg1;
11768   {
11769     try {
11770       (arg1)->Conjugate();
11771     } catch (std::out_of_range& e) {
11772       {
11773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (std::exception& e) {
11776       {
11777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11778       };
11779     } catch (Dali::DaliException e) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11782       };
11783     } catch (...) {
11784       {
11785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11786       };
11787     }
11788   }
11789
11790 }
11791
11792
11793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11794   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11795
11796   arg1 = (Dali::Quaternion *)jarg1;
11797   {
11798     try {
11799       (arg1)->Invert();
11800     } catch (std::out_of_range& e) {
11801       {
11802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11803       };
11804     } catch (std::exception& e) {
11805       {
11806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11807       };
11808     } catch (Dali::DaliException e) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11815       };
11816     }
11817   }
11818
11819 }
11820
11821
11822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11823   void * jresult ;
11824   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11825   Dali::Quaternion result;
11826
11827   arg1 = (Dali::Quaternion *)jarg1;
11828   {
11829     try {
11830       result = ((Dali::Quaternion const *)arg1)->Log();
11831     } catch (std::out_of_range& e) {
11832       {
11833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11834       };
11835     } catch (std::exception& e) {
11836       {
11837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11838       };
11839     } catch (Dali::DaliException e) {
11840       {
11841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11842       };
11843     } catch (...) {
11844       {
11845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11846       };
11847     }
11848   }
11849
11850   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11851   return jresult;
11852 }
11853
11854
11855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11856   void * jresult ;
11857   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11858   Dali::Quaternion result;
11859
11860   arg1 = (Dali::Quaternion *)jarg1;
11861   {
11862     try {
11863       result = ((Dali::Quaternion const *)arg1)->Exp();
11864     } catch (std::out_of_range& e) {
11865       {
11866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11867       };
11868     } catch (std::exception& e) {
11869       {
11870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11871       };
11872     } catch (Dali::DaliException e) {
11873       {
11874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11875       };
11876     } catch (...) {
11877       {
11878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11879       };
11880     }
11881   }
11882
11883   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11884   return jresult;
11885 }
11886
11887
11888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11889   float jresult ;
11890   Dali::Quaternion *arg1 = 0 ;
11891   Dali::Quaternion *arg2 = 0 ;
11892   float result;
11893
11894   arg1 = (Dali::Quaternion *)jarg1;
11895   if (!arg1) {
11896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11897     return 0;
11898   }
11899   arg2 = (Dali::Quaternion *)jarg2;
11900   if (!arg2) {
11901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11902     return 0;
11903   }
11904   {
11905     try {
11906       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11907     } catch (std::out_of_range& e) {
11908       {
11909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11910       };
11911     } catch (std::exception& e) {
11912       {
11913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11914       };
11915     } catch (Dali::DaliException e) {
11916       {
11917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11918       };
11919     } catch (...) {
11920       {
11921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11922       };
11923     }
11924   }
11925
11926   jresult = result;
11927   return jresult;
11928 }
11929
11930
11931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11932   void * jresult ;
11933   Dali::Quaternion *arg1 = 0 ;
11934   Dali::Quaternion *arg2 = 0 ;
11935   float arg3 ;
11936   Dali::Quaternion result;
11937
11938   arg1 = (Dali::Quaternion *)jarg1;
11939   if (!arg1) {
11940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11941     return 0;
11942   }
11943   arg2 = (Dali::Quaternion *)jarg2;
11944   if (!arg2) {
11945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11946     return 0;
11947   }
11948   arg3 = (float)jarg3;
11949   {
11950     try {
11951       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11952     } catch (std::out_of_range& e) {
11953       {
11954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11955       };
11956     } catch (std::exception& e) {
11957       {
11958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11959       };
11960     } catch (Dali::DaliException e) {
11961       {
11962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11963       };
11964     } catch (...) {
11965       {
11966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11967       };
11968     }
11969   }
11970
11971   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11972   return jresult;
11973 }
11974
11975
11976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11977   void * jresult ;
11978   Dali::Quaternion *arg1 = 0 ;
11979   Dali::Quaternion *arg2 = 0 ;
11980   float arg3 ;
11981   Dali::Quaternion result;
11982
11983   arg1 = (Dali::Quaternion *)jarg1;
11984   if (!arg1) {
11985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11986     return 0;
11987   }
11988   arg2 = (Dali::Quaternion *)jarg2;
11989   if (!arg2) {
11990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11991     return 0;
11992   }
11993   arg3 = (float)jarg3;
11994   {
11995     try {
11996       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11997     } catch (std::out_of_range& e) {
11998       {
11999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12000       };
12001     } catch (std::exception& e) {
12002       {
12003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12004       };
12005     } catch (Dali::DaliException e) {
12006       {
12007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12008       };
12009     } catch (...) {
12010       {
12011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12012       };
12013     }
12014   }
12015
12016   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12017   return jresult;
12018 }
12019
12020
12021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12022   void * jresult ;
12023   Dali::Quaternion *arg1 = 0 ;
12024   Dali::Quaternion *arg2 = 0 ;
12025   float arg3 ;
12026   Dali::Quaternion result;
12027
12028   arg1 = (Dali::Quaternion *)jarg1;
12029   if (!arg1) {
12030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12031     return 0;
12032   }
12033   arg2 = (Dali::Quaternion *)jarg2;
12034   if (!arg2) {
12035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12036     return 0;
12037   }
12038   arg3 = (float)jarg3;
12039   {
12040     try {
12041       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12042     } catch (std::out_of_range& e) {
12043       {
12044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12045       };
12046     } catch (std::exception& e) {
12047       {
12048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12049       };
12050     } catch (Dali::DaliException e) {
12051       {
12052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12053       };
12054     } catch (...) {
12055       {
12056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12057       };
12058     }
12059   }
12060
12061   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12067   void * jresult ;
12068   Dali::Quaternion *arg1 = 0 ;
12069   Dali::Quaternion *arg2 = 0 ;
12070   Dali::Quaternion *arg3 = 0 ;
12071   Dali::Quaternion *arg4 = 0 ;
12072   float arg5 ;
12073   Dali::Quaternion result;
12074
12075   arg1 = (Dali::Quaternion *)jarg1;
12076   if (!arg1) {
12077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12078     return 0;
12079   }
12080   arg2 = (Dali::Quaternion *)jarg2;
12081   if (!arg2) {
12082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12083     return 0;
12084   }
12085   arg3 = (Dali::Quaternion *)jarg3;
12086   if (!arg3) {
12087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12088     return 0;
12089   }
12090   arg4 = (Dali::Quaternion *)jarg4;
12091   if (!arg4) {
12092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12093     return 0;
12094   }
12095   arg5 = (float)jarg5;
12096   {
12097     try {
12098       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12099     } catch (std::out_of_range& e) {
12100       {
12101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12102       };
12103     } catch (std::exception& e) {
12104       {
12105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12106       };
12107     } catch (Dali::DaliException e) {
12108       {
12109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12110       };
12111     } catch (...) {
12112       {
12113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12114       };
12115     }
12116   }
12117
12118   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12119   return jresult;
12120 }
12121
12122
12123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12124   float jresult ;
12125   Dali::Quaternion *arg1 = 0 ;
12126   Dali::Quaternion *arg2 = 0 ;
12127   float result;
12128
12129   arg1 = (Dali::Quaternion *)jarg1;
12130   if (!arg1) {
12131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12132     return 0;
12133   }
12134   arg2 = (Dali::Quaternion *)jarg2;
12135   if (!arg2) {
12136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12137     return 0;
12138   }
12139   {
12140     try {
12141       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12142     } catch (std::out_of_range& e) {
12143       {
12144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12145       };
12146     } catch (std::exception& e) {
12147       {
12148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12149       };
12150     } catch (Dali::DaliException e) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12153       };
12154     } catch (...) {
12155       {
12156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12157       };
12158     }
12159   }
12160
12161   jresult = result;
12162   return jresult;
12163 }
12164
12165
12166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12167   void * jresult ;
12168   Dali::Matrix *result = 0 ;
12169
12170   {
12171     try {
12172       result = (Dali::Matrix *)new Dali::Matrix();
12173     } catch (std::out_of_range& e) {
12174       {
12175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12176       };
12177     } catch (std::exception& e) {
12178       {
12179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12180       };
12181     } catch (Dali::DaliException e) {
12182       {
12183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12184       };
12185     } catch (...) {
12186       {
12187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12188       };
12189     }
12190   }
12191
12192   jresult = (void *)result;
12193   return jresult;
12194 }
12195
12196
12197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12198   void * jresult ;
12199   bool arg1 ;
12200   Dali::Matrix *result = 0 ;
12201
12202   arg1 = jarg1 ? true : false;
12203   {
12204     try {
12205       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12206     } catch (std::out_of_range& e) {
12207       {
12208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12209       };
12210     } catch (std::exception& e) {
12211       {
12212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12213       };
12214     } catch (Dali::DaliException e) {
12215       {
12216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12217       };
12218     } catch (...) {
12219       {
12220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12221       };
12222     }
12223   }
12224
12225   jresult = (void *)result;
12226   return jresult;
12227 }
12228
12229
12230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12231   void * jresult ;
12232   float *arg1 = (float *) 0 ;
12233   Dali::Matrix *result = 0 ;
12234
12235   arg1 = jarg1;
12236   {
12237     try {
12238       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12239     } catch (std::out_of_range& e) {
12240       {
12241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12242       };
12243     } catch (std::exception& e) {
12244       {
12245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12246       };
12247     } catch (Dali::DaliException e) {
12248       {
12249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12250       };
12251     } catch (...) {
12252       {
12253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12254       };
12255     }
12256   }
12257
12258   jresult = (void *)result;
12259
12260
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12266   void * jresult ;
12267   Dali::Quaternion *arg1 = 0 ;
12268   Dali::Matrix *result = 0 ;
12269
12270   arg1 = (Dali::Quaternion *)jarg1;
12271   if (!arg1) {
12272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12273     return 0;
12274   }
12275   {
12276     try {
12277       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12278     } catch (std::out_of_range& e) {
12279       {
12280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12281       };
12282     } catch (std::exception& e) {
12283       {
12284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (Dali::DaliException e) {
12287       {
12288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12289       };
12290     } catch (...) {
12291       {
12292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12293       };
12294     }
12295   }
12296
12297   jresult = (void *)result;
12298   return jresult;
12299 }
12300
12301
12302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12303   void * jresult ;
12304   Dali::Matrix *arg1 = 0 ;
12305   Dali::Matrix *result = 0 ;
12306
12307   arg1 = (Dali::Matrix *)jarg1;
12308   if (!arg1) {
12309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12310     return 0;
12311   }
12312   {
12313     try {
12314       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12315     } catch (std::out_of_range& e) {
12316       {
12317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12318       };
12319     } catch (std::exception& e) {
12320       {
12321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (Dali::DaliException e) {
12324       {
12325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12326       };
12327     } catch (...) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12330       };
12331     }
12332   }
12333
12334   jresult = (void *)result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12340   void * jresult ;
12341   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12342   Dali::Matrix *arg2 = 0 ;
12343   Dali::Matrix *result = 0 ;
12344
12345   arg1 = (Dali::Matrix *)jarg1;
12346   arg2 = (Dali::Matrix *)jarg2;
12347   if (!arg2) {
12348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12349     return 0;
12350   }
12351   {
12352     try {
12353       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12354     } catch (std::out_of_range& e) {
12355       {
12356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12357       };
12358     } catch (std::exception& e) {
12359       {
12360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12361       };
12362     } catch (Dali::DaliException e) {
12363       {
12364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12365       };
12366     } catch (...) {
12367       {
12368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12369       };
12370     }
12371   }
12372
12373   jresult = (void *)result;
12374   return jresult;
12375 }
12376
12377
12378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12379   void * jresult ;
12380   Dali::Matrix *result = 0 ;
12381
12382   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12383   jresult = (void *)result;
12384   return jresult;
12385 }
12386
12387
12388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12389   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12390
12391   arg1 = (Dali::Matrix *)jarg1;
12392   {
12393     try {
12394       (arg1)->SetIdentity();
12395     } catch (std::out_of_range& e) {
12396       {
12397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12398       };
12399     } catch (std::exception& e) {
12400       {
12401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12402       };
12403     } catch (Dali::DaliException e) {
12404       {
12405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12406       };
12407     } catch (...) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12410       };
12411     }
12412   }
12413
12414 }
12415
12416
12417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12418   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12419   Dali::Vector3 *arg2 = 0 ;
12420
12421   arg1 = (Dali::Matrix *)jarg1;
12422   arg2 = (Dali::Vector3 *)jarg2;
12423   if (!arg2) {
12424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12425     return ;
12426   }
12427   {
12428     try {
12429       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (Dali::DaliException e) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12441       };
12442     } catch (...) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12445       };
12446     }
12447   }
12448
12449 }
12450
12451
12452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12453   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12454   Dali::Matrix *arg2 = 0 ;
12455
12456   arg1 = (Dali::Matrix *)jarg1;
12457   arg2 = (Dali::Matrix *)jarg2;
12458   if (!arg2) {
12459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12460     return ;
12461   }
12462   {
12463     try {
12464       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12465     } catch (std::out_of_range& e) {
12466       {
12467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12468       };
12469     } catch (std::exception& e) {
12470       {
12471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12472       };
12473     } catch (Dali::DaliException e) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12476       };
12477     } catch (...) {
12478       {
12479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12480       };
12481     }
12482   }
12483
12484 }
12485
12486
12487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12488   unsigned int jresult ;
12489   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12490   bool result;
12491
12492   arg1 = (Dali::Matrix *)jarg1;
12493   {
12494     try {
12495       result = (bool)(arg1)->Invert();
12496     } catch (std::out_of_range& e) {
12497       {
12498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12499       };
12500     } catch (std::exception& e) {
12501       {
12502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12503       };
12504     } catch (Dali::DaliException e) {
12505       {
12506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12507       };
12508     } catch (...) {
12509       {
12510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12511       };
12512     }
12513   }
12514
12515   jresult = result;
12516   return jresult;
12517 }
12518
12519
12520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12521   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12522
12523   arg1 = (Dali::Matrix *)jarg1;
12524   {
12525     try {
12526       (arg1)->Transpose();
12527     } catch (std::out_of_range& e) {
12528       {
12529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12530       };
12531     } catch (std::exception& e) {
12532       {
12533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12534       };
12535     } catch (Dali::DaliException e) {
12536       {
12537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12538       };
12539     } catch (...) {
12540       {
12541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12542       };
12543     }
12544   }
12545
12546 }
12547
12548
12549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12550   void * jresult ;
12551   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12552   Dali::Vector3 result;
12553
12554   arg1 = (Dali::Matrix *)jarg1;
12555   {
12556     try {
12557       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12558     } catch (std::out_of_range& e) {
12559       {
12560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12561       };
12562     } catch (std::exception& e) {
12563       {
12564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12565       };
12566     } catch (Dali::DaliException e) {
12567       {
12568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12569       };
12570     } catch (...) {
12571       {
12572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12573       };
12574     }
12575   }
12576
12577   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12578   return jresult;
12579 }
12580
12581
12582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12583   void * jresult ;
12584   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12585   Dali::Vector3 result;
12586
12587   arg1 = (Dali::Matrix *)jarg1;
12588   {
12589     try {
12590       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12591     } catch (std::out_of_range& e) {
12592       {
12593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12594       };
12595     } catch (std::exception& e) {
12596       {
12597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12598       };
12599     } catch (Dali::DaliException e) {
12600       {
12601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12602       };
12603     } catch (...) {
12604       {
12605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12606       };
12607     }
12608   }
12609
12610   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12611   return jresult;
12612 }
12613
12614
12615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12616   void * jresult ;
12617   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12618   Dali::Vector3 result;
12619
12620   arg1 = (Dali::Matrix *)jarg1;
12621   {
12622     try {
12623       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12624     } catch (std::out_of_range& e) {
12625       {
12626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12627       };
12628     } catch (std::exception& e) {
12629       {
12630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12631       };
12632     } catch (Dali::DaliException e) {
12633       {
12634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12635       };
12636     } catch (...) {
12637       {
12638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12639       };
12640     }
12641   }
12642
12643   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12644   return jresult;
12645 }
12646
12647
12648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12649   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12650   Dali::Vector3 *arg2 = 0 ;
12651
12652   arg1 = (Dali::Matrix *)jarg1;
12653   arg2 = (Dali::Vector3 *)jarg2;
12654   if (!arg2) {
12655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12656     return ;
12657   }
12658   {
12659     try {
12660       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12661     } catch (std::out_of_range& e) {
12662       {
12663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12664       };
12665     } catch (std::exception& e) {
12666       {
12667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (Dali::DaliException e) {
12670       {
12671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12672       };
12673     } catch (...) {
12674       {
12675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12676       };
12677     }
12678   }
12679
12680 }
12681
12682
12683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12684   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12685   Dali::Vector3 *arg2 = 0 ;
12686
12687   arg1 = (Dali::Matrix *)jarg1;
12688   arg2 = (Dali::Vector3 *)jarg2;
12689   if (!arg2) {
12690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12691     return ;
12692   }
12693   {
12694     try {
12695       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12696     } catch (std::out_of_range& e) {
12697       {
12698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12699       };
12700     } catch (std::exception& e) {
12701       {
12702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12703       };
12704     } catch (Dali::DaliException e) {
12705       {
12706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12707       };
12708     } catch (...) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12711       };
12712     }
12713   }
12714
12715 }
12716
12717
12718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12719   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12720   Dali::Vector3 *arg2 = 0 ;
12721
12722   arg1 = (Dali::Matrix *)jarg1;
12723   arg2 = (Dali::Vector3 *)jarg2;
12724   if (!arg2) {
12725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12726     return ;
12727   }
12728   {
12729     try {
12730       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12731     } catch (std::out_of_range& e) {
12732       {
12733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12734       };
12735     } catch (std::exception& e) {
12736       {
12737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12738       };
12739     } catch (Dali::DaliException e) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12742       };
12743     } catch (...) {
12744       {
12745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12746       };
12747     }
12748   }
12749
12750 }
12751
12752
12753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12754   void * jresult ;
12755   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12756   Dali::Vector4 *result = 0 ;
12757
12758   arg1 = (Dali::Matrix *)jarg1;
12759   {
12760     try {
12761       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12762     } catch (std::out_of_range& e) {
12763       {
12764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12765       };
12766     } catch (std::exception& e) {
12767       {
12768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12769       };
12770     } catch (Dali::DaliException e) {
12771       {
12772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12773       };
12774     } catch (...) {
12775       {
12776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12777       };
12778     }
12779   }
12780
12781   jresult = (void *)result;
12782   return jresult;
12783 }
12784
12785
12786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12787   void * jresult ;
12788   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12789   Dali::Vector3 *result = 0 ;
12790
12791   arg1 = (Dali::Matrix *)jarg1;
12792   {
12793     try {
12794       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12795     } catch (std::out_of_range& e) {
12796       {
12797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12798       };
12799     } catch (std::exception& e) {
12800       {
12801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12802       };
12803     } catch (Dali::DaliException e) {
12804       {
12805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12806       };
12807     } catch (...) {
12808       {
12809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12810       };
12811     }
12812   }
12813
12814   jresult = (void *)result;
12815   return jresult;
12816 }
12817
12818
12819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12820   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12821   Dali::Vector4 *arg2 = 0 ;
12822
12823   arg1 = (Dali::Matrix *)jarg1;
12824   arg2 = (Dali::Vector4 *)jarg2;
12825   if (!arg2) {
12826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12827     return ;
12828   }
12829   {
12830     try {
12831       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12832     } catch (std::out_of_range& e) {
12833       {
12834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12835       };
12836     } catch (std::exception& e) {
12837       {
12838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12839       };
12840     } catch (Dali::DaliException e) {
12841       {
12842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12847       };
12848     }
12849   }
12850
12851 }
12852
12853
12854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12855   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12856   Dali::Vector3 *arg2 = 0 ;
12857
12858   arg1 = (Dali::Matrix *)jarg1;
12859   arg2 = (Dali::Vector3 *)jarg2;
12860   if (!arg2) {
12861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12862     return ;
12863   }
12864   {
12865     try {
12866       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12867     } catch (std::out_of_range& e) {
12868       {
12869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12870       };
12871     } catch (std::exception& e) {
12872       {
12873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12874       };
12875     } catch (Dali::DaliException e) {
12876       {
12877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12878       };
12879     } catch (...) {
12880       {
12881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12882       };
12883     }
12884   }
12885
12886 }
12887
12888
12889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12890   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12891
12892   arg1 = (Dali::Matrix *)jarg1;
12893   {
12894     try {
12895       (arg1)->OrthoNormalize();
12896     } catch (std::out_of_range& e) {
12897       {
12898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12899       };
12900     } catch (std::exception& e) {
12901       {
12902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12903       };
12904     } catch (Dali::DaliException e) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12907       };
12908     } catch (...) {
12909       {
12910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12911       };
12912     }
12913   }
12914
12915 }
12916
12917
12918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12919   void * jresult ;
12920   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12921   float *result = 0 ;
12922
12923   arg1 = (Dali::Matrix *)jarg1;
12924   {
12925     try {
12926       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12927     } catch (std::out_of_range& e) {
12928       {
12929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12930       };
12931     } catch (std::exception& e) {
12932       {
12933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12934       };
12935     } catch (Dali::DaliException e) {
12936       {
12937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12938       };
12939     } catch (...) {
12940       {
12941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12942       };
12943     }
12944   }
12945
12946   jresult = (void *)result;
12947   return jresult;
12948 }
12949
12950
12951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12952   Dali::Matrix *arg1 = 0 ;
12953   Dali::Matrix *arg2 = 0 ;
12954   Dali::Matrix *arg3 = 0 ;
12955
12956   arg1 = (Dali::Matrix *)jarg1;
12957   if (!arg1) {
12958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12959     return ;
12960   }
12961   arg2 = (Dali::Matrix *)jarg2;
12962   if (!arg2) {
12963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12964     return ;
12965   }
12966   arg3 = (Dali::Matrix *)jarg3;
12967   if (!arg3) {
12968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12969     return ;
12970   }
12971   {
12972     try {
12973       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12974     } catch (std::out_of_range& e) {
12975       {
12976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12977       };
12978     } catch (std::exception& e) {
12979       {
12980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12981       };
12982     } catch (Dali::DaliException e) {
12983       {
12984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12985       };
12986     } catch (...) {
12987       {
12988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12989       };
12990     }
12991   }
12992
12993 }
12994
12995
12996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12997   Dali::Matrix *arg1 = 0 ;
12998   Dali::Matrix *arg2 = 0 ;
12999   Dali::Quaternion *arg3 = 0 ;
13000
13001   arg1 = (Dali::Matrix *)jarg1;
13002   if (!arg1) {
13003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13004     return ;
13005   }
13006   arg2 = (Dali::Matrix *)jarg2;
13007   if (!arg2) {
13008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13009     return ;
13010   }
13011   arg3 = (Dali::Quaternion *)jarg3;
13012   if (!arg3) {
13013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13014     return ;
13015   }
13016   {
13017     try {
13018       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13019     } catch (std::out_of_range& e) {
13020       {
13021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13022       };
13023     } catch (std::exception& e) {
13024       {
13025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13026       };
13027     } catch (Dali::DaliException e) {
13028       {
13029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13030       };
13031     } catch (...) {
13032       {
13033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13034       };
13035     }
13036   }
13037
13038 }
13039
13040
13041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13042   void * jresult ;
13043   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13044   Dali::Vector4 *arg2 = 0 ;
13045   Dali::Vector4 result;
13046
13047   arg1 = (Dali::Matrix *)jarg1;
13048   arg2 = (Dali::Vector4 *)jarg2;
13049   if (!arg2) {
13050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13051     return 0;
13052   }
13053   {
13054     try {
13055       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13056     } catch (std::out_of_range& e) {
13057       {
13058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13059       };
13060     } catch (std::exception& e) {
13061       {
13062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13063       };
13064     } catch (Dali::DaliException e) {
13065       {
13066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13067       };
13068     } catch (...) {
13069       {
13070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13071       };
13072     }
13073   }
13074
13075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13076   return jresult;
13077 }
13078
13079
13080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13081   unsigned int jresult ;
13082   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13083   Dali::Matrix *arg2 = 0 ;
13084   bool result;
13085
13086   arg1 = (Dali::Matrix *)jarg1;
13087   arg2 = (Dali::Matrix *)jarg2;
13088   if (!arg2) {
13089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13090     return 0;
13091   }
13092   {
13093     try {
13094       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13095     } catch (std::out_of_range& e) {
13096       {
13097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13098       };
13099     } catch (std::exception& e) {
13100       {
13101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13102       };
13103     } catch (Dali::DaliException e) {
13104       {
13105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13106       };
13107     } catch (...) {
13108       {
13109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13110       };
13111     }
13112   }
13113
13114   jresult = result;
13115   return jresult;
13116 }
13117
13118
13119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13120   unsigned int jresult ;
13121   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13122   Dali::Matrix *arg2 = 0 ;
13123   bool result;
13124
13125   arg1 = (Dali::Matrix *)jarg1;
13126   arg2 = (Dali::Matrix *)jarg2;
13127   if (!arg2) {
13128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13129     return 0;
13130   }
13131   {
13132     try {
13133       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13134     } catch (std::out_of_range& e) {
13135       {
13136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13137       };
13138     } catch (std::exception& e) {
13139       {
13140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13141       };
13142     } catch (Dali::DaliException e) {
13143       {
13144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13145       };
13146     } catch (...) {
13147       {
13148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13149       };
13150     }
13151   }
13152
13153   jresult = result;
13154   return jresult;
13155 }
13156
13157
13158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13159   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13160   Dali::Vector3 *arg2 = 0 ;
13161   Dali::Quaternion *arg3 = 0 ;
13162   Dali::Vector3 *arg4 = 0 ;
13163
13164   arg1 = (Dali::Matrix *)jarg1;
13165   arg2 = (Dali::Vector3 *)jarg2;
13166   if (!arg2) {
13167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13168     return ;
13169   }
13170   arg3 = (Dali::Quaternion *)jarg3;
13171   if (!arg3) {
13172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13173     return ;
13174   }
13175   arg4 = (Dali::Vector3 *)jarg4;
13176   if (!arg4) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13178     return ;
13179   }
13180   {
13181     try {
13182       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13183     } catch (std::out_of_range& e) {
13184       {
13185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13186       };
13187     } catch (std::exception& e) {
13188       {
13189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13190       };
13191     } catch (Dali::DaliException e) {
13192       {
13193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13194       };
13195     } catch (...) {
13196       {
13197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13198       };
13199     }
13200   }
13201
13202 }
13203
13204
13205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13206   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13207   Dali::Vector3 *arg2 = 0 ;
13208   Dali::Quaternion *arg3 = 0 ;
13209   Dali::Vector3 *arg4 = 0 ;
13210
13211   arg1 = (Dali::Matrix *)jarg1;
13212   arg2 = (Dali::Vector3 *)jarg2;
13213   if (!arg2) {
13214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13215     return ;
13216   }
13217   arg3 = (Dali::Quaternion *)jarg3;
13218   if (!arg3) {
13219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13220     return ;
13221   }
13222   arg4 = (Dali::Vector3 *)jarg4;
13223   if (!arg4) {
13224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13225     return ;
13226   }
13227   {
13228     try {
13229       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13230     } catch (std::out_of_range& e) {
13231       {
13232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13233       };
13234     } catch (std::exception& e) {
13235       {
13236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13237       };
13238     } catch (Dali::DaliException e) {
13239       {
13240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13241       };
13242     } catch (...) {
13243       {
13244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13245       };
13246     }
13247   }
13248
13249 }
13250
13251
13252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13253   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13254   Dali::Vector3 *arg2 = 0 ;
13255   Dali::Vector3 *arg3 = 0 ;
13256   Dali::Vector3 *arg4 = 0 ;
13257   Dali::Vector3 *arg5 = 0 ;
13258
13259   arg1 = (Dali::Matrix *)jarg1;
13260   arg2 = (Dali::Vector3 *)jarg2;
13261   if (!arg2) {
13262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13263     return ;
13264   }
13265   arg3 = (Dali::Vector3 *)jarg3;
13266   if (!arg3) {
13267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13268     return ;
13269   }
13270   arg4 = (Dali::Vector3 *)jarg4;
13271   if (!arg4) {
13272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13273     return ;
13274   }
13275   arg5 = (Dali::Vector3 *)jarg5;
13276   if (!arg5) {
13277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13278     return ;
13279   }
13280   {
13281     try {
13282       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13283     } catch (std::out_of_range& e) {
13284       {
13285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13286       };
13287     } catch (std::exception& e) {
13288       {
13289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13290       };
13291     } catch (Dali::DaliException e) {
13292       {
13293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13294       };
13295     } catch (...) {
13296       {
13297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13298       };
13299     }
13300   }
13301
13302 }
13303
13304
13305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13306   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13307   Dali::Vector3 *arg2 = 0 ;
13308   Dali::Quaternion *arg3 = 0 ;
13309   Dali::Vector3 *arg4 = 0 ;
13310
13311   arg1 = (Dali::Matrix *)jarg1;
13312   arg2 = (Dali::Vector3 *)jarg2;
13313   if (!arg2) {
13314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13315     return ;
13316   }
13317   arg3 = (Dali::Quaternion *)jarg3;
13318   if (!arg3) {
13319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13320     return ;
13321   }
13322   arg4 = (Dali::Vector3 *)jarg4;
13323   if (!arg4) {
13324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13325     return ;
13326   }
13327   {
13328     try {
13329       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13330     } catch (std::out_of_range& e) {
13331       {
13332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13333       };
13334     } catch (std::exception& e) {
13335       {
13336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13337       };
13338     } catch (Dali::DaliException e) {
13339       {
13340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13345       };
13346     }
13347   }
13348
13349 }
13350
13351
13352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13353   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13354
13355   arg1 = (Dali::Matrix *)jarg1;
13356   {
13357     try {
13358       delete arg1;
13359     } catch (std::out_of_range& e) {
13360       {
13361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13362       };
13363     } catch (std::exception& e) {
13364       {
13365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13366       };
13367     } catch (Dali::DaliException e) {
13368       {
13369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13370       };
13371     } catch (...) {
13372       {
13373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13374       };
13375     }
13376   }
13377
13378 }
13379
13380
13381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13382   void * jresult ;
13383   Dali::Matrix3 *result = 0 ;
13384
13385   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13386   jresult = (void *)result;
13387   return jresult;
13388 }
13389
13390
13391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13392   void * jresult ;
13393   Dali::Matrix3 *result = 0 ;
13394
13395   {
13396     try {
13397       result = (Dali::Matrix3 *)new Dali::Matrix3();
13398     } catch (std::out_of_range& e) {
13399       {
13400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13401       };
13402     } catch (std::exception& e) {
13403       {
13404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13405       };
13406     } catch (Dali::DaliException e) {
13407       {
13408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13409       };
13410     } catch (...) {
13411       {
13412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13413       };
13414     }
13415   }
13416
13417   jresult = (void *)result;
13418   return jresult;
13419 }
13420
13421
13422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13423   void * jresult ;
13424   Dali::Matrix3 *arg1 = 0 ;
13425   Dali::Matrix3 *result = 0 ;
13426
13427   arg1 = (Dali::Matrix3 *)jarg1;
13428   if (!arg1) {
13429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13430     return 0;
13431   }
13432   {
13433     try {
13434       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13435     } catch (std::out_of_range& e) {
13436       {
13437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13438       };
13439     } catch (std::exception& e) {
13440       {
13441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13442       };
13443     } catch (Dali::DaliException e) {
13444       {
13445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13446       };
13447     } catch (...) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13450       };
13451     }
13452   }
13453
13454   jresult = (void *)result;
13455   return jresult;
13456 }
13457
13458
13459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13460   void * jresult ;
13461   Dali::Matrix *arg1 = 0 ;
13462   Dali::Matrix3 *result = 0 ;
13463
13464   arg1 = (Dali::Matrix *)jarg1;
13465   if (!arg1) {
13466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13467     return 0;
13468   }
13469   {
13470     try {
13471       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13472     } catch (std::out_of_range& e) {
13473       {
13474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13475       };
13476     } catch (std::exception& e) {
13477       {
13478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13479       };
13480     } catch (Dali::DaliException e) {
13481       {
13482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13483       };
13484     } catch (...) {
13485       {
13486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13487       };
13488     }
13489   }
13490
13491   jresult = (void *)result;
13492   return jresult;
13493 }
13494
13495
13496 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) {
13497   void * jresult ;
13498   float arg1 ;
13499   float arg2 ;
13500   float arg3 ;
13501   float arg4 ;
13502   float arg5 ;
13503   float arg6 ;
13504   float arg7 ;
13505   float arg8 ;
13506   float arg9 ;
13507   Dali::Matrix3 *result = 0 ;
13508
13509   arg1 = (float)jarg1;
13510   arg2 = (float)jarg2;
13511   arg3 = (float)jarg3;
13512   arg4 = (float)jarg4;
13513   arg5 = (float)jarg5;
13514   arg6 = (float)jarg6;
13515   arg7 = (float)jarg7;
13516   arg8 = (float)jarg8;
13517   arg9 = (float)jarg9;
13518   {
13519     try {
13520       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13521     } catch (std::out_of_range& e) {
13522       {
13523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13524       };
13525     } catch (std::exception& e) {
13526       {
13527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13528       };
13529     } catch (Dali::DaliException e) {
13530       {
13531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13532       };
13533     } catch (...) {
13534       {
13535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13536       };
13537     }
13538   }
13539
13540   jresult = (void *)result;
13541   return jresult;
13542 }
13543
13544
13545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13546   void * jresult ;
13547   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13548   Dali::Matrix3 *arg2 = 0 ;
13549   Dali::Matrix3 *result = 0 ;
13550
13551   arg1 = (Dali::Matrix3 *)jarg1;
13552   arg2 = (Dali::Matrix3 *)jarg2;
13553   if (!arg2) {
13554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13555     return 0;
13556   }
13557   {
13558     try {
13559       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13560     } catch (std::out_of_range& e) {
13561       {
13562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13563       };
13564     } catch (std::exception& e) {
13565       {
13566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (Dali::DaliException e) {
13569       {
13570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13571       };
13572     } catch (...) {
13573       {
13574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13575       };
13576     }
13577   }
13578
13579   jresult = (void *)result;
13580   return jresult;
13581 }
13582
13583
13584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13585   void * jresult ;
13586   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13587   Dali::Matrix *arg2 = 0 ;
13588   Dali::Matrix3 *result = 0 ;
13589
13590   arg1 = (Dali::Matrix3 *)jarg1;
13591   arg2 = (Dali::Matrix *)jarg2;
13592   if (!arg2) {
13593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13594     return 0;
13595   }
13596   {
13597     try {
13598       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13599     } catch (std::out_of_range& e) {
13600       {
13601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13602       };
13603     } catch (std::exception& e) {
13604       {
13605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13606       };
13607     } catch (Dali::DaliException e) {
13608       {
13609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13610       };
13611     } catch (...) {
13612       {
13613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13614       };
13615     }
13616   }
13617
13618   jresult = (void *)result;
13619   return jresult;
13620 }
13621
13622
13623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13624   unsigned int jresult ;
13625   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13626   Dali::Matrix3 *arg2 = 0 ;
13627   bool result;
13628
13629   arg1 = (Dali::Matrix3 *)jarg1;
13630   arg2 = (Dali::Matrix3 *)jarg2;
13631   if (!arg2) {
13632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13633     return 0;
13634   }
13635   {
13636     try {
13637       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13638     } catch (std::out_of_range& e) {
13639       {
13640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13641       };
13642     } catch (std::exception& e) {
13643       {
13644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13645       };
13646     } catch (Dali::DaliException e) {
13647       {
13648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13649       };
13650     } catch (...) {
13651       {
13652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13653       };
13654     }
13655   }
13656
13657   jresult = result;
13658   return jresult;
13659 }
13660
13661
13662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13663   unsigned int jresult ;
13664   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13665   Dali::Matrix3 *arg2 = 0 ;
13666   bool result;
13667
13668   arg1 = (Dali::Matrix3 *)jarg1;
13669   arg2 = (Dali::Matrix3 *)jarg2;
13670   if (!arg2) {
13671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13672     return 0;
13673   }
13674   {
13675     try {
13676       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13677     } catch (std::out_of_range& e) {
13678       {
13679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13680       };
13681     } catch (std::exception& e) {
13682       {
13683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13684       };
13685     } catch (Dali::DaliException e) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13692       };
13693     }
13694   }
13695
13696   jresult = result;
13697   return jresult;
13698 }
13699
13700
13701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13702   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13703
13704   arg1 = (Dali::Matrix3 *)jarg1;
13705   {
13706     try {
13707       delete arg1;
13708     } catch (std::out_of_range& e) {
13709       {
13710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13711       };
13712     } catch (std::exception& e) {
13713       {
13714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13715       };
13716     } catch (Dali::DaliException e) {
13717       {
13718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13719       };
13720     } catch (...) {
13721       {
13722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13723       };
13724     }
13725   }
13726
13727 }
13728
13729
13730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13731   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13732
13733   arg1 = (Dali::Matrix3 *)jarg1;
13734   {
13735     try {
13736       (arg1)->SetIdentity();
13737     } catch (std::out_of_range& e) {
13738       {
13739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13740       };
13741     } catch (std::exception& e) {
13742       {
13743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13744       };
13745     } catch (Dali::DaliException e) {
13746       {
13747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13748       };
13749     } catch (...) {
13750       {
13751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13752       };
13753     }
13754   }
13755
13756 }
13757
13758
13759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13760   void * jresult ;
13761   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13762   float *result = 0 ;
13763
13764   arg1 = (Dali::Matrix3 *)jarg1;
13765   {
13766     try {
13767       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13768     } catch (std::out_of_range& e) {
13769       {
13770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13771       };
13772     } catch (std::exception& e) {
13773       {
13774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13775       };
13776     } catch (Dali::DaliException e) {
13777       {
13778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13779       };
13780     } catch (...) {
13781       {
13782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13783       };
13784     }
13785   }
13786
13787   jresult = (void *)result;
13788   return jresult;
13789 }
13790
13791
13792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13793   unsigned int jresult ;
13794   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13795   bool result;
13796
13797   arg1 = (Dali::Matrix3 *)jarg1;
13798   {
13799     try {
13800       result = (bool)(arg1)->Invert();
13801     } catch (std::out_of_range& e) {
13802       {
13803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13804       };
13805     } catch (std::exception& e) {
13806       {
13807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13808       };
13809     } catch (Dali::DaliException e) {
13810       {
13811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13812       };
13813     } catch (...) {
13814       {
13815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13816       };
13817     }
13818   }
13819
13820   jresult = result;
13821   return jresult;
13822 }
13823
13824
13825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13826   unsigned int jresult ;
13827   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13828   bool result;
13829
13830   arg1 = (Dali::Matrix3 *)jarg1;
13831   {
13832     try {
13833       result = (bool)(arg1)->Transpose();
13834     } catch (std::out_of_range& e) {
13835       {
13836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13837       };
13838     } catch (std::exception& e) {
13839       {
13840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13841       };
13842     } catch (Dali::DaliException e) {
13843       {
13844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13845       };
13846     } catch (...) {
13847       {
13848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13849       };
13850     }
13851   }
13852
13853   jresult = result;
13854   return jresult;
13855 }
13856
13857
13858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13859   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13860   float arg2 ;
13861
13862   arg1 = (Dali::Matrix3 *)jarg1;
13863   arg2 = (float)jarg2;
13864   {
13865     try {
13866       (arg1)->Scale(arg2);
13867     } catch (std::out_of_range& e) {
13868       {
13869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13870       };
13871     } catch (std::exception& e) {
13872       {
13873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13874       };
13875     } catch (Dali::DaliException e) {
13876       {
13877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13878       };
13879     } catch (...) {
13880       {
13881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13882       };
13883     }
13884   }
13885
13886 }
13887
13888
13889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13890   float jresult ;
13891   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13892   float result;
13893
13894   arg1 = (Dali::Matrix3 *)jarg1;
13895   {
13896     try {
13897       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13898     } catch (std::out_of_range& e) {
13899       {
13900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (std::exception& e) {
13903       {
13904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (Dali::DaliException e) {
13907       {
13908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13909       };
13910     } catch (...) {
13911       {
13912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13913       };
13914     }
13915   }
13916
13917   jresult = result;
13918   return jresult;
13919 }
13920
13921
13922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13923   unsigned int jresult ;
13924   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13925   bool result;
13926
13927   arg1 = (Dali::Matrix3 *)jarg1;
13928   {
13929     try {
13930       result = (bool)(arg1)->ScaledInverseTranspose();
13931     } catch (std::out_of_range& e) {
13932       {
13933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13934       };
13935     } catch (std::exception& e) {
13936       {
13937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13938       };
13939     } catch (Dali::DaliException e) {
13940       {
13941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13942       };
13943     } catch (...) {
13944       {
13945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13946       };
13947     }
13948   }
13949
13950   jresult = result;
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13956   Dali::Matrix3 *arg1 = 0 ;
13957   Dali::Matrix3 *arg2 = 0 ;
13958   Dali::Matrix3 *arg3 = 0 ;
13959
13960   arg1 = (Dali::Matrix3 *)jarg1;
13961   if (!arg1) {
13962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13963     return ;
13964   }
13965   arg2 = (Dali::Matrix3 *)jarg2;
13966   if (!arg2) {
13967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13968     return ;
13969   }
13970   arg3 = (Dali::Matrix3 *)jarg3;
13971   if (!arg3) {
13972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13973     return ;
13974   }
13975   {
13976     try {
13977       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13978     } catch (std::out_of_range& e) {
13979       {
13980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13981       };
13982     } catch (std::exception& e) {
13983       {
13984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13985       };
13986     } catch (Dali::DaliException e) {
13987       {
13988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13989       };
13990     } catch (...) {
13991       {
13992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13993       };
13994     }
13995   }
13996
13997 }
13998
13999
14000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14001   float jresult ;
14002   float arg1 ;
14003   float arg2 ;
14004   float result;
14005
14006   arg1 = (float)jarg1;
14007   arg2 = (float)jarg2;
14008   {
14009     try {
14010       result = (float)Dali::Random::Range(arg1,arg2);
14011     } catch (std::out_of_range& e) {
14012       {
14013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14014       };
14015     } catch (std::exception& e) {
14016       {
14017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14018       };
14019     } catch (Dali::DaliException e) {
14020       {
14021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14022       };
14023     } catch (...) {
14024       {
14025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14026       };
14027     }
14028   }
14029
14030   jresult = result;
14031   return jresult;
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14036   void * jresult ;
14037   Dali::Vector4 result;
14038
14039   {
14040     try {
14041       result = Dali::Random::Axis();
14042     } catch (std::out_of_range& e) {
14043       {
14044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (std::exception& e) {
14047       {
14048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14049       };
14050     } catch (Dali::DaliException e) {
14051       {
14052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14057       };
14058     }
14059   }
14060
14061   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14062   return jresult;
14063 }
14064
14065
14066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14067   void * jresult ;
14068   Dali::AngleAxis *result = 0 ;
14069
14070   {
14071     try {
14072       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14073     } catch (std::out_of_range& e) {
14074       {
14075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14076       };
14077     } catch (std::exception& e) {
14078       {
14079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14080       };
14081     } catch (Dali::DaliException e) {
14082       {
14083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14084       };
14085     } catch (...) {
14086       {
14087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14088       };
14089     }
14090   }
14091
14092   jresult = (void *)result;
14093   return jresult;
14094 }
14095
14096
14097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14098   void * jresult ;
14099   Dali::Radian arg1 ;
14100   Dali::Vector3 *arg2 = 0 ;
14101   Dali::Radian *argp1 ;
14102   Dali::AngleAxis *result = 0 ;
14103
14104   argp1 = (Dali::Radian *)jarg1;
14105   if (!argp1) {
14106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14107     return 0;
14108   }
14109   arg1 = *argp1;
14110   arg2 = (Dali::Vector3 *)jarg2;
14111   if (!arg2) {
14112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14113     return 0;
14114   }
14115   {
14116     try {
14117       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14118     } catch (std::out_of_range& e) {
14119       {
14120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14121       };
14122     } catch (std::exception& e) {
14123       {
14124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14125       };
14126     } catch (Dali::DaliException e) {
14127       {
14128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14129       };
14130     } catch (...) {
14131       {
14132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14133       };
14134     }
14135   }
14136
14137   jresult = (void *)result;
14138   return jresult;
14139 }
14140
14141
14142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14143   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14144   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14145
14146   arg1 = (Dali::AngleAxis *)jarg1;
14147   arg2 = (Dali::Radian *)jarg2;
14148   if (arg1) (arg1)->angle = *arg2;
14149 }
14150
14151
14152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14153   void * jresult ;
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155   Dali::Radian *result = 0 ;
14156
14157   arg1 = (Dali::AngleAxis *)jarg1;
14158   result = (Dali::Radian *)& ((arg1)->angle);
14159   jresult = (void *)result;
14160   return jresult;
14161 }
14162
14163
14164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14165   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14166   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14167
14168   arg1 = (Dali::AngleAxis *)jarg1;
14169   arg2 = (Dali::Vector3 *)jarg2;
14170   if (arg1) (arg1)->axis = *arg2;
14171 }
14172
14173
14174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14175   void * jresult ;
14176   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14177   Dali::Vector3 *result = 0 ;
14178
14179   arg1 = (Dali::AngleAxis *)jarg1;
14180   result = (Dali::Vector3 *)& ((arg1)->axis);
14181   jresult = (void *)result;
14182   return jresult;
14183 }
14184
14185
14186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14187   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14188
14189   arg1 = (Dali::AngleAxis *)jarg1;
14190   {
14191     try {
14192       delete arg1;
14193     } catch (std::out_of_range& e) {
14194       {
14195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14196       };
14197     } catch (std::exception& e) {
14198       {
14199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14200       };
14201     } catch (Dali::DaliException e) {
14202       {
14203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14204       };
14205     } catch (...) {
14206       {
14207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14208       };
14209     }
14210   }
14211
14212 }
14213
14214
14215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14216   unsigned int jresult ;
14217   Dali::AngleAxis *arg1 = 0 ;
14218   Dali::AngleAxis *arg2 = 0 ;
14219   bool result;
14220
14221   arg1 = (Dali::AngleAxis *)jarg1;
14222   if (!arg1) {
14223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14224     return 0;
14225   }
14226   arg2 = (Dali::AngleAxis *)jarg2;
14227   if (!arg2) {
14228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14229     return 0;
14230   }
14231   {
14232     try {
14233       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14234     } catch (std::out_of_range& e) {
14235       {
14236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14237       };
14238     } catch (std::exception& e) {
14239       {
14240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14241       };
14242     } catch (Dali::DaliException e) {
14243       {
14244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14245       };
14246     } catch (...) {
14247       {
14248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14249       };
14250     }
14251   }
14252
14253   jresult = result;
14254   return jresult;
14255 }
14256
14257
14258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14259   unsigned int jresult ;
14260   unsigned int arg1 ;
14261   unsigned int result;
14262
14263   arg1 = (unsigned int)jarg1;
14264   {
14265     try {
14266       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14267     } catch (std::out_of_range& e) {
14268       {
14269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14270       };
14271     } catch (std::exception& e) {
14272       {
14273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14274       };
14275     } catch (Dali::DaliException e) {
14276       {
14277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14278       };
14279     } catch (...) {
14280       {
14281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14282       };
14283     }
14284   }
14285
14286   jresult = result;
14287   return jresult;
14288 }
14289
14290
14291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14292   unsigned int jresult ;
14293   unsigned int arg1 ;
14294   bool result;
14295
14296   arg1 = (unsigned int)jarg1;
14297   {
14298     try {
14299       result = (bool)Dali::IsPowerOfTwo(arg1);
14300     } catch (std::out_of_range& e) {
14301       {
14302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14303       };
14304     } catch (std::exception& e) {
14305       {
14306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14307       };
14308     } catch (Dali::DaliException e) {
14309       {
14310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14311       };
14312     } catch (...) {
14313       {
14314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14315       };
14316     }
14317   }
14318
14319   jresult = result;
14320   return jresult;
14321 }
14322
14323
14324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14325   float jresult ;
14326   float arg1 ;
14327   float arg2 ;
14328   float result;
14329
14330   arg1 = (float)jarg1;
14331   arg2 = (float)jarg2;
14332   {
14333     try {
14334       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14335     } catch (std::out_of_range& e) {
14336       {
14337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14338       };
14339     } catch (std::exception& e) {
14340       {
14341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14342       };
14343     } catch (Dali::DaliException e) {
14344       {
14345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14346       };
14347     } catch (...) {
14348       {
14349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14350       };
14351     }
14352   }
14353
14354   jresult = result;
14355   return jresult;
14356 }
14357
14358
14359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14360   unsigned int jresult ;
14361   float arg1 ;
14362   bool result;
14363
14364   arg1 = (float)jarg1;
14365   {
14366     try {
14367       result = (bool)Dali::EqualsZero(arg1);
14368     } catch (std::out_of_range& e) {
14369       {
14370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14371       };
14372     } catch (std::exception& e) {
14373       {
14374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (Dali::DaliException e) {
14377       {
14378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14379       };
14380     } catch (...) {
14381       {
14382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14383       };
14384     }
14385   }
14386
14387   jresult = result;
14388   return jresult;
14389 }
14390
14391
14392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14393   unsigned int jresult ;
14394   float arg1 ;
14395   float arg2 ;
14396   bool result;
14397
14398   arg1 = (float)jarg1;
14399   arg2 = (float)jarg2;
14400   {
14401     try {
14402       result = (bool)Dali::Equals(arg1,arg2);
14403     } catch (std::out_of_range& e) {
14404       {
14405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14406       };
14407     } catch (std::exception& e) {
14408       {
14409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14410       };
14411     } catch (Dali::DaliException e) {
14412       {
14413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14414       };
14415     } catch (...) {
14416       {
14417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14418       };
14419     }
14420   }
14421
14422   jresult = result;
14423   return jresult;
14424 }
14425
14426
14427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14428   unsigned int jresult ;
14429   float arg1 ;
14430   float arg2 ;
14431   float arg3 ;
14432   bool result;
14433
14434   arg1 = (float)jarg1;
14435   arg2 = (float)jarg2;
14436   arg3 = (float)jarg3;
14437   {
14438     try {
14439       result = (bool)Dali::Equals(arg1,arg2,arg3);
14440     } catch (std::out_of_range& e) {
14441       {
14442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14443       };
14444     } catch (std::exception& e) {
14445       {
14446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (Dali::DaliException e) {
14449       {
14450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14451       };
14452     } catch (...) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14455       };
14456     }
14457   }
14458
14459   jresult = result;
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14465   float jresult ;
14466   float arg1 ;
14467   int arg2 ;
14468   float result;
14469
14470   arg1 = (float)jarg1;
14471   arg2 = (int)jarg2;
14472   {
14473     try {
14474       result = (float)Dali::Round(arg1,arg2);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (Dali::DaliException e) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14486       };
14487     } catch (...) {
14488       {
14489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14490       };
14491     }
14492   }
14493
14494   jresult = result;
14495   return jresult;
14496 }
14497
14498
14499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14500   float jresult ;
14501   float arg1 ;
14502   float arg2 ;
14503   float arg3 ;
14504   float result;
14505
14506   arg1 = (float)jarg1;
14507   arg2 = (float)jarg2;
14508   arg3 = (float)jarg3;
14509   {
14510     try {
14511       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14512     } catch (std::out_of_range& e) {
14513       {
14514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14515       };
14516     } catch (std::exception& e) {
14517       {
14518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14519       };
14520     } catch (Dali::DaliException e) {
14521       {
14522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14523       };
14524     } catch (...) {
14525       {
14526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14527       };
14528     }
14529   }
14530
14531   jresult = result;
14532   return jresult;
14533 }
14534
14535
14536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14537   float jresult ;
14538   float arg1 ;
14539   float arg2 ;
14540   float arg3 ;
14541   float arg4 ;
14542   float result;
14543
14544   arg1 = (float)jarg1;
14545   arg2 = (float)jarg2;
14546   arg3 = (float)jarg3;
14547   arg4 = (float)jarg4;
14548   {
14549     try {
14550       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14551     } catch (std::out_of_range& e) {
14552       {
14553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14554       };
14555     } catch (std::exception& e) {
14556       {
14557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14558       };
14559     } catch (Dali::DaliException e) {
14560       {
14561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14562       };
14563     } catch (...) {
14564       {
14565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14566       };
14567     }
14568   }
14569
14570   jresult = result;
14571   return jresult;
14572 }
14573
14574
14575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14576   int jresult ;
14577   int result;
14578
14579   result = (int)(int)Dali::Property::INVALID_INDEX;
14580   jresult = result;
14581   return jresult;
14582 }
14583
14584
14585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14586   int jresult ;
14587   int result;
14588
14589   result = (int)(int)Dali::Property::INVALID_KEY;
14590   jresult = result;
14591   return jresult;
14592 }
14593
14594
14595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14596   int jresult ;
14597   int result;
14598
14599   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14600   jresult = result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14606   void * jresult ;
14607   Dali::Handle *arg1 = 0 ;
14608   Dali::Property::Index arg2 ;
14609   Dali::Property *result = 0 ;
14610
14611   arg1 = (Dali::Handle *)jarg1;
14612   if (!arg1) {
14613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14614     return 0;
14615   }
14616   arg2 = (Dali::Property::Index)jarg2;
14617   {
14618     try {
14619       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14620     } catch (std::out_of_range& e) {
14621       {
14622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14623       };
14624     } catch (std::exception& e) {
14625       {
14626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14627       };
14628     } catch (Dali::DaliException e) {
14629       {
14630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14631       };
14632     } catch (...) {
14633       {
14634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14635       };
14636     }
14637   }
14638
14639   jresult = (void *)result;
14640   return jresult;
14641 }
14642
14643
14644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14645   void * jresult ;
14646   Dali::Handle *arg1 = 0 ;
14647   Dali::Property::Index arg2 ;
14648   int arg3 ;
14649   Dali::Property *result = 0 ;
14650
14651   arg1 = (Dali::Handle *)jarg1;
14652   if (!arg1) {
14653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14654     return 0;
14655   }
14656   arg2 = (Dali::Property::Index)jarg2;
14657   arg3 = (int)jarg3;
14658   {
14659     try {
14660       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14661     } catch (std::out_of_range& e) {
14662       {
14663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14664       };
14665     } catch (std::exception& e) {
14666       {
14667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14668       };
14669     } catch (Dali::DaliException e) {
14670       {
14671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14672       };
14673     } catch (...) {
14674       {
14675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14676       };
14677     }
14678   }
14679
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14686   void * jresult ;
14687   Dali::Handle *arg1 = 0 ;
14688   std::string *arg2 = 0 ;
14689   Dali::Property *result = 0 ;
14690
14691   arg1 = (Dali::Handle *)jarg1;
14692   if (!arg1) {
14693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14694     return 0;
14695   }
14696   if (!jarg2) {
14697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14698     return 0;
14699   }
14700   std::string arg2_str(jarg2);
14701   arg2 = &arg2_str;
14702   {
14703     try {
14704       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14705     } catch (std::out_of_range& e) {
14706       {
14707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14708       };
14709     } catch (std::exception& e) {
14710       {
14711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14712       };
14713     } catch (Dali::DaliException e) {
14714       {
14715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14716       };
14717     } catch (...) {
14718       {
14719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14720       };
14721     }
14722   }
14723
14724   jresult = (void *)result;
14725
14726   //argout typemap for const std::string&
14727
14728   return jresult;
14729 }
14730
14731
14732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14733   void * jresult ;
14734   Dali::Handle *arg1 = 0 ;
14735   std::string *arg2 = 0 ;
14736   int arg3 ;
14737   Dali::Property *result = 0 ;
14738
14739   arg1 = (Dali::Handle *)jarg1;
14740   if (!arg1) {
14741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14742     return 0;
14743   }
14744   if (!jarg2) {
14745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14746     return 0;
14747   }
14748   std::string arg2_str(jarg2);
14749   arg2 = &arg2_str;
14750   arg3 = (int)jarg3;
14751   {
14752     try {
14753       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14754     } catch (std::out_of_range& e) {
14755       {
14756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14757       };
14758     } catch (std::exception& e) {
14759       {
14760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14761       };
14762     } catch (Dali::DaliException e) {
14763       {
14764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14765       };
14766     } catch (...) {
14767       {
14768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14769       };
14770     }
14771   }
14772
14773   jresult = (void *)result;
14774
14775   //argout typemap for const std::string&
14776
14777   return jresult;
14778 }
14779
14780
14781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14782   Dali::Property *arg1 = (Dali::Property *) 0 ;
14783
14784   arg1 = (Dali::Property *)jarg1;
14785   {
14786     try {
14787       delete arg1;
14788     } catch (std::out_of_range& e) {
14789       {
14790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14791       };
14792     } catch (std::exception& e) {
14793       {
14794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14795       };
14796     } catch (Dali::DaliException e) {
14797       {
14798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14799       };
14800     } catch (...) {
14801       {
14802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14803       };
14804     }
14805   }
14806
14807 }
14808
14809
14810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14811   Dali::Property *arg1 = (Dali::Property *) 0 ;
14812   Dali::Handle *arg2 = 0 ;
14813
14814   arg1 = (Dali::Property *)jarg1;
14815   arg2 = (Dali::Handle *)jarg2;
14816   if (!arg2) {
14817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14818     return ;
14819   }
14820   if (arg1) (arg1)->object = *arg2;
14821 }
14822
14823
14824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14825   void * jresult ;
14826   Dali::Property *arg1 = (Dali::Property *) 0 ;
14827   Dali::Handle *result = 0 ;
14828
14829   arg1 = (Dali::Property *)jarg1;
14830   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14831   jresult = (void *)result;
14832   return jresult;
14833 }
14834
14835
14836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   Dali::Property::Index arg2 ;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   arg2 = (Dali::Property::Index)jarg2;
14842   if (arg1) (arg1)->propertyIndex = arg2;
14843 }
14844
14845
14846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14847   int jresult ;
14848   Dali::Property *arg1 = (Dali::Property *) 0 ;
14849   Dali::Property::Index result;
14850
14851   arg1 = (Dali::Property *)jarg1;
14852   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14853   jresult = result;
14854   return jresult;
14855 }
14856
14857
14858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14859   Dali::Property *arg1 = (Dali::Property *) 0 ;
14860   int arg2 ;
14861
14862   arg1 = (Dali::Property *)jarg1;
14863   arg2 = (int)jarg2;
14864   if (arg1) (arg1)->componentIndex = arg2;
14865 }
14866
14867
14868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14869   int jresult ;
14870   Dali::Property *arg1 = (Dali::Property *) 0 ;
14871   int result;
14872
14873   arg1 = (Dali::Property *)jarg1;
14874   result = (int) ((arg1)->componentIndex);
14875   jresult = result;
14876   return jresult;
14877 }
14878
14879
14880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14881   void * jresult ;
14882   Dali::Property::Array *result = 0 ;
14883
14884   {
14885     try {
14886       result = (Dali::Property::Array *)new Dali::Property::Array();
14887     } catch (std::out_of_range& e) {
14888       {
14889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14890       };
14891     } catch (std::exception& e) {
14892       {
14893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14894       };
14895     } catch (Dali::DaliException e) {
14896       {
14897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14898       };
14899     } catch (...) {
14900       {
14901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14902       };
14903     }
14904   }
14905
14906   jresult = (void *)result;
14907   return jresult;
14908 }
14909
14910
14911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14912   void * jresult ;
14913   Dali::Property::Array *arg1 = 0 ;
14914   Dali::Property::Array *result = 0 ;
14915
14916   arg1 = (Dali::Property::Array *)jarg1;
14917   if (!arg1) {
14918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14919     return 0;
14920   }
14921   {
14922     try {
14923       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14924     } catch (std::out_of_range& e) {
14925       {
14926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14927       };
14928     } catch (std::exception& e) {
14929       {
14930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14931       };
14932     } catch (Dali::DaliException e) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14935       };
14936     } catch (...) {
14937       {
14938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14939       };
14940     }
14941   }
14942
14943   jresult = (void *)result;
14944   return jresult;
14945 }
14946
14947
14948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14949   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14950
14951   arg1 = (Dali::Property::Array *)jarg1;
14952   {
14953     try {
14954       delete arg1;
14955     } catch (std::out_of_range& e) {
14956       {
14957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14958       };
14959     } catch (std::exception& e) {
14960       {
14961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14962       };
14963     } catch (Dali::DaliException e) {
14964       {
14965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14966       };
14967     } catch (...) {
14968       {
14969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14970       };
14971     }
14972   }
14973
14974 }
14975
14976
14977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14978   unsigned long jresult ;
14979   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14980   Dali::Property::Array::SizeType result;
14981
14982   arg1 = (Dali::Property::Array *)jarg1;
14983   {
14984     try {
14985       result = ((Dali::Property::Array const *)arg1)->Size();
14986     } catch (std::out_of_range& e) {
14987       {
14988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14989       };
14990     } catch (std::exception& e) {
14991       {
14992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14993       };
14994     } catch (Dali::DaliException e) {
14995       {
14996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14997       };
14998     } catch (...) {
14999       {
15000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15001       };
15002     }
15003   }
15004
15005   jresult = (unsigned long)result;
15006   return jresult;
15007 }
15008
15009
15010 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15011   unsigned long jresult ;
15012   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15013   Dali::Property::Array::SizeType result;
15014
15015   arg1 = (Dali::Property::Array *)jarg1;
15016   {
15017     try {
15018       result = ((Dali::Property::Array const *)arg1)->Count();
15019     } catch (std::out_of_range& e) {
15020       {
15021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15022       };
15023     } catch (std::exception& e) {
15024       {
15025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15026       };
15027     } catch (Dali::DaliException e) {
15028       {
15029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15030       };
15031     } catch (...) {
15032       {
15033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15034       };
15035     }
15036   }
15037
15038   jresult = (unsigned long)result;
15039   return jresult;
15040 }
15041
15042
15043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15044   unsigned int jresult ;
15045   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15046   bool result;
15047
15048   arg1 = (Dali::Property::Array *)jarg1;
15049   {
15050     try {
15051       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15052     } catch (std::out_of_range& e) {
15053       {
15054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15055       };
15056     } catch (std::exception& e) {
15057       {
15058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15059       };
15060     } catch (Dali::DaliException e) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15063       };
15064     } catch (...) {
15065       {
15066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15067       };
15068     }
15069   }
15070
15071   jresult = result;
15072   return jresult;
15073 }
15074
15075
15076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15077   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15078
15079   arg1 = (Dali::Property::Array *)jarg1;
15080   {
15081     try {
15082       (arg1)->Clear();
15083     } catch (std::out_of_range& e) {
15084       {
15085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15086       };
15087     } catch (std::exception& e) {
15088       {
15089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15090       };
15091     } catch (Dali::DaliException e) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15094       };
15095     } catch (...) {
15096       {
15097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15098       };
15099     }
15100   }
15101
15102 }
15103
15104
15105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15106   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15107   Dali::Property::Array::SizeType arg2 ;
15108
15109   arg1 = (Dali::Property::Array *)jarg1;
15110   arg2 = (Dali::Property::Array::SizeType)jarg2;
15111   {
15112     try {
15113       (arg1)->Reserve(arg2);
15114     } catch (std::out_of_range& e) {
15115       {
15116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15117       };
15118     } catch (std::exception& e) {
15119       {
15120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15121       };
15122     } catch (Dali::DaliException e) {
15123       {
15124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15125       };
15126     } catch (...) {
15127       {
15128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15129       };
15130     }
15131   }
15132
15133 }
15134
15135
15136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15137   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15138   Dali::Property::Array::SizeType arg2 ;
15139
15140   arg1 = (Dali::Property::Array *)jarg1;
15141   arg2 = (Dali::Property::Array::SizeType)jarg2;
15142   {
15143     try {
15144       (arg1)->Resize(arg2);
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15152       };
15153     } catch (Dali::DaliException e) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15156       };
15157     } catch (...) {
15158       {
15159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15160       };
15161     }
15162   }
15163
15164 }
15165
15166
15167 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15168   unsigned long jresult ;
15169   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15170   Dali::Property::Array::SizeType result;
15171
15172   arg1 = (Dali::Property::Array *)jarg1;
15173   {
15174     try {
15175       result = (arg1)->Capacity();
15176     } catch (std::out_of_range& e) {
15177       {
15178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15179       };
15180     } catch (std::exception& e) {
15181       {
15182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (Dali::DaliException e) {
15185       {
15186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15187       };
15188     } catch (...) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15191       };
15192     }
15193   }
15194
15195   jresult = (unsigned long)result;
15196   return jresult;
15197 }
15198
15199
15200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15201   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15202   Dali::Property::Value *arg2 = 0 ;
15203
15204   arg1 = (Dali::Property::Array *)jarg1;
15205   arg2 = (Dali::Property::Value *)jarg2;
15206   if (!arg2) {
15207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15208     return ;
15209   }
15210   {
15211     try {
15212       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15213     } catch (std::out_of_range& e) {
15214       {
15215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15216       };
15217     } catch (std::exception& e) {
15218       {
15219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15220       };
15221     } catch (Dali::DaliException e) {
15222       {
15223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15224       };
15225     } catch (...) {
15226       {
15227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15228       };
15229     }
15230   }
15231
15232 }
15233
15234
15235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15236   void * jresult ;
15237   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15238   Dali::Property::Value *arg2 = 0 ;
15239   Dali::Property::Array *result = 0 ;
15240
15241   arg1 = (Dali::Property::Array *)jarg1;
15242   arg2 = (Dali::Property::Value *)jarg2;
15243   if (!arg2) {
15244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15245     return 0;
15246   }
15247   {
15248     try {
15249       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15250     } catch (std::out_of_range& e) {
15251       {
15252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15253       };
15254     } catch (std::exception& e) {
15255       {
15256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (Dali::DaliException e) {
15259       {
15260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15261       };
15262     } catch (...) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15265       };
15266     }
15267   }
15268
15269   jresult = (void *)result;
15270   return jresult;
15271 }
15272
15273
15274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15275   void * jresult ;
15276   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15277   Dali::Property::Array::SizeType arg2 ;
15278   Dali::Property::Value *result = 0 ;
15279
15280   arg1 = (Dali::Property::Array *)jarg1;
15281   arg2 = (Dali::Property::Array::SizeType)jarg2;
15282   {
15283     try {
15284       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15285     } catch (std::out_of_range& e) {
15286       {
15287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15288       };
15289     } catch (std::exception& e) {
15290       {
15291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (Dali::DaliException e) {
15294       {
15295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15296       };
15297     } catch (...) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15300       };
15301     }
15302   }
15303
15304   jresult = (void *)result;
15305   return jresult;
15306 }
15307
15308
15309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15310   void * jresult ;
15311   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15312   Dali::Property::Array::SizeType arg2 ;
15313   Dali::Property::Value *result = 0 ;
15314
15315   arg1 = (Dali::Property::Array *)jarg1;
15316   arg2 = (Dali::Property::Array::SizeType)jarg2;
15317   {
15318     try {
15319       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15320     } catch (std::out_of_range& e) {
15321       {
15322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15323       };
15324     } catch (std::exception& e) {
15325       {
15326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15327       };
15328     } catch (Dali::DaliException e) {
15329       {
15330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15331       };
15332     } catch (...) {
15333       {
15334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15335       };
15336     }
15337   }
15338
15339   jresult = (void *)result;
15340   return jresult;
15341 }
15342
15343
15344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15345   void * jresult ;
15346   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15347   Dali::Property::Array *arg2 = 0 ;
15348   Dali::Property::Array *result = 0 ;
15349
15350   arg1 = (Dali::Property::Array *)jarg1;
15351   arg2 = (Dali::Property::Array *)jarg2;
15352   if (!arg2) {
15353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15354     return 0;
15355   }
15356   {
15357     try {
15358       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15359     } catch (std::out_of_range& e) {
15360       {
15361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (std::exception& e) {
15364       {
15365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15366       };
15367     } catch (Dali::DaliException e) {
15368       {
15369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15370       };
15371     } catch (...) {
15372       {
15373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15374       };
15375     }
15376   }
15377
15378   jresult = (void *)result;
15379   return jresult;
15380 }
15381
15382
15383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15384   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15385   enum Dali::Property::Key::Type arg2 ;
15386
15387   arg1 = (Dali::Property::Key *)jarg1;
15388   arg2 = (enum Dali::Property::Key::Type)jarg2;
15389   if (arg1) (arg1)->type = arg2;
15390 }
15391
15392
15393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15394   int jresult ;
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   enum Dali::Property::Key::Type result;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15400   jresult = (int)result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15406   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15407   Dali::Property::Index arg2 ;
15408
15409   arg1 = (Dali::Property::Key *)jarg1;
15410   arg2 = (Dali::Property::Index)jarg2;
15411   if (arg1) (arg1)->indexKey = arg2;
15412 }
15413
15414
15415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15416   int jresult ;
15417   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15418   Dali::Property::Index result;
15419
15420   arg1 = (Dali::Property::Key *)jarg1;
15421   result = (Dali::Property::Index) ((arg1)->indexKey);
15422   jresult = result;
15423   return jresult;
15424 }
15425
15426
15427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15428   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15429   std::string *arg2 = 0 ;
15430
15431   arg1 = (Dali::Property::Key *)jarg1;
15432   if (!jarg2) {
15433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15434     return ;
15435   }
15436   std::string arg2_str(jarg2);
15437   arg2 = &arg2_str;
15438   if (arg1) (arg1)->stringKey = *arg2;
15439
15440   //argout typemap for const std::string&
15441
15442 }
15443
15444
15445 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15446   char * jresult ;
15447   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15448   std::string *result = 0 ;
15449
15450   arg1 = (Dali::Property::Key *)jarg1;
15451   result = (std::string *) & ((arg1)->stringKey);
15452   jresult = SWIG_csharp_string_callback(result->c_str());
15453   return jresult;
15454 }
15455
15456
15457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15458   void * jresult ;
15459   std::string *arg1 = 0 ;
15460   Dali::Property::Key *result = 0 ;
15461
15462   if (!jarg1) {
15463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15464     return 0;
15465   }
15466   std::string arg1_str(jarg1);
15467   arg1 = &arg1_str;
15468   {
15469     try {
15470       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15471     } catch (std::out_of_range& e) {
15472       {
15473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15474       };
15475     } catch (std::exception& e) {
15476       {
15477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15478       };
15479     } catch (Dali::DaliException e) {
15480       {
15481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15482       };
15483     } catch (...) {
15484       {
15485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15486       };
15487     }
15488   }
15489
15490   jresult = (void *)result;
15491
15492   //argout typemap for const std::string&
15493
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15499   void * jresult ;
15500   Dali::Property::Index arg1 ;
15501   Dali::Property::Key *result = 0 ;
15502
15503   arg1 = (Dali::Property::Index)jarg1;
15504   {
15505     try {
15506       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15507     } catch (std::out_of_range& e) {
15508       {
15509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15510       };
15511     } catch (std::exception& e) {
15512       {
15513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15514       };
15515     } catch (Dali::DaliException e) {
15516       {
15517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15518       };
15519     } catch (...) {
15520       {
15521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15522       };
15523     }
15524   }
15525
15526   jresult = (void *)result;
15527   return jresult;
15528 }
15529
15530
15531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15532   unsigned int jresult ;
15533   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15534   std::string *arg2 = 0 ;
15535   bool result;
15536
15537   arg1 = (Dali::Property::Key *)jarg1;
15538   if (!jarg2) {
15539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15540     return 0;
15541   }
15542   std::string arg2_str(jarg2);
15543   arg2 = &arg2_str;
15544   {
15545     try {
15546       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15547     } catch (std::out_of_range& e) {
15548       {
15549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15550       };
15551     } catch (std::exception& e) {
15552       {
15553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15554       };
15555     } catch (Dali::DaliException e) {
15556       {
15557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15558       };
15559     } catch (...) {
15560       {
15561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15562       };
15563     }
15564   }
15565
15566   jresult = result;
15567
15568   //argout typemap for const std::string&
15569
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15575   unsigned int jresult ;
15576   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15577   Dali::Property::Index arg2 ;
15578   bool result;
15579
15580   arg1 = (Dali::Property::Key *)jarg1;
15581   arg2 = (Dali::Property::Index)jarg2;
15582   {
15583     try {
15584       result = (bool)(arg1)->operator ==(arg2);
15585     } catch (std::out_of_range& e) {
15586       {
15587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15588       };
15589     } catch (std::exception& e) {
15590       {
15591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15592       };
15593     } catch (Dali::DaliException e) {
15594       {
15595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15596       };
15597     } catch (...) {
15598       {
15599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15600       };
15601     }
15602   }
15603
15604   jresult = result;
15605   return jresult;
15606 }
15607
15608
15609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15610   unsigned int jresult ;
15611   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15612   Dali::Property::Key *arg2 = 0 ;
15613   bool result;
15614
15615   arg1 = (Dali::Property::Key *)jarg1;
15616   arg2 = (Dali::Property::Key *)jarg2;
15617   if (!arg2) {
15618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15619     return 0;
15620   }
15621   {
15622     try {
15623       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15624     } catch (std::out_of_range& e) {
15625       {
15626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15627       };
15628     } catch (std::exception& e) {
15629       {
15630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15631       };
15632     } catch (Dali::DaliException e) {
15633       {
15634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15635       };
15636     } catch (...) {
15637       {
15638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15639       };
15640     }
15641   }
15642
15643   jresult = result;
15644   return jresult;
15645 }
15646
15647
15648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15649   unsigned int jresult ;
15650   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15651   std::string *arg2 = 0 ;
15652   bool result;
15653
15654   arg1 = (Dali::Property::Key *)jarg1;
15655   if (!jarg2) {
15656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15657     return 0;
15658   }
15659   std::string arg2_str(jarg2);
15660   arg2 = &arg2_str;
15661   {
15662     try {
15663       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15664     } catch (std::out_of_range& e) {
15665       {
15666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15667       };
15668     } catch (std::exception& e) {
15669       {
15670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15671       };
15672     } catch (Dali::DaliException e) {
15673       {
15674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15675       };
15676     } catch (...) {
15677       {
15678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15679       };
15680     }
15681   }
15682
15683   jresult = result;
15684
15685   //argout typemap for const std::string&
15686
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15694   Dali::Property::Index arg2 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Key *)jarg1;
15698   arg2 = (Dali::Property::Index)jarg2;
15699   {
15700     try {
15701       result = (bool)(arg1)->operator !=(arg2);
15702     } catch (std::out_of_range& e) {
15703       {
15704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15705       };
15706     } catch (std::exception& e) {
15707       {
15708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (Dali::DaliException e) {
15711       {
15712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15713       };
15714     } catch (...) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15717       };
15718     }
15719   }
15720
15721   jresult = result;
15722   return jresult;
15723 }
15724
15725
15726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15727   unsigned int jresult ;
15728   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15729   Dali::Property::Key *arg2 = 0 ;
15730   bool result;
15731
15732   arg1 = (Dali::Property::Key *)jarg1;
15733   arg2 = (Dali::Property::Key *)jarg2;
15734   if (!arg2) {
15735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15736     return 0;
15737   }
15738   {
15739     try {
15740       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15741     } catch (std::out_of_range& e) {
15742       {
15743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15744       };
15745     } catch (std::exception& e) {
15746       {
15747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15748       };
15749     } catch (Dali::DaliException e) {
15750       {
15751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15752       };
15753     } catch (...) {
15754       {
15755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15756       };
15757     }
15758   }
15759
15760   jresult = result;
15761   return jresult;
15762 }
15763
15764
15765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15766   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15767
15768   arg1 = (Dali::Property::Key *)jarg1;
15769   {
15770     try {
15771       delete arg1;
15772     } catch (std::out_of_range& e) {
15773       {
15774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15775       };
15776     } catch (std::exception& e) {
15777       {
15778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15779       };
15780     } catch (Dali::DaliException e) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15783       };
15784     } catch (...) {
15785       {
15786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15787       };
15788     }
15789   }
15790
15791 }
15792
15793
15794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15795   void * jresult ;
15796   Dali::Property::Map *result = 0 ;
15797
15798   {
15799     try {
15800       result = (Dali::Property::Map *)new Dali::Property::Map();
15801     } catch (std::out_of_range& e) {
15802       {
15803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15804       };
15805     } catch (std::exception& e) {
15806       {
15807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15808       };
15809     } catch (Dali::DaliException e) {
15810       {
15811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15812       };
15813     } catch (...) {
15814       {
15815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15816       };
15817     }
15818   }
15819
15820   jresult = (void *)result;
15821   return jresult;
15822 }
15823
15824
15825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15826   void * jresult ;
15827   Dali::Property::Map *arg1 = 0 ;
15828   Dali::Property::Map *result = 0 ;
15829
15830   arg1 = (Dali::Property::Map *)jarg1;
15831   if (!arg1) {
15832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15833     return 0;
15834   }
15835   {
15836     try {
15837       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15838     } catch (std::out_of_range& e) {
15839       {
15840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15841       };
15842     } catch (std::exception& e) {
15843       {
15844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15845       };
15846     } catch (Dali::DaliException e) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15849       };
15850     } catch (...) {
15851       {
15852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15853       };
15854     }
15855   }
15856
15857   jresult = (void *)result;
15858   return jresult;
15859 }
15860
15861
15862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15863   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15864
15865   arg1 = (Dali::Property::Map *)jarg1;
15866   {
15867     try {
15868       delete arg1;
15869     } catch (std::out_of_range& e) {
15870       {
15871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15872       };
15873     } catch (std::exception& e) {
15874       {
15875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15876       };
15877     } catch (Dali::DaliException e) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15880       };
15881     } catch (...) {
15882       {
15883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15884       };
15885     }
15886   }
15887
15888 }
15889
15890
15891 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15892   unsigned long jresult ;
15893   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15894   Dali::Property::Map::SizeType result;
15895
15896   arg1 = (Dali::Property::Map *)jarg1;
15897   {
15898     try {
15899       result = ((Dali::Property::Map const *)arg1)->Count();
15900     } catch (std::out_of_range& e) {
15901       {
15902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15903       };
15904     } catch (std::exception& e) {
15905       {
15906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15907       };
15908     } catch (Dali::DaliException e) {
15909       {
15910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15911       };
15912     } catch (...) {
15913       {
15914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15915       };
15916     }
15917   }
15918
15919   jresult = (unsigned long)result;
15920   return jresult;
15921 }
15922
15923
15924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15925   unsigned int jresult ;
15926   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15927   bool result;
15928
15929   arg1 = (Dali::Property::Map *)jarg1;
15930   {
15931     try {
15932       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15933     } catch (std::out_of_range& e) {
15934       {
15935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15936       };
15937     } catch (std::exception& e) {
15938       {
15939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15940       };
15941     } catch (Dali::DaliException e) {
15942       {
15943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15944       };
15945     } catch (...) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15948       };
15949     }
15950   }
15951
15952   jresult = result;
15953   return jresult;
15954 }
15955
15956
15957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15958   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15959   char *arg2 = (char *) 0 ;
15960   Dali::Property::Value *arg3 = 0 ;
15961
15962   arg1 = (Dali::Property::Map *)jarg1;
15963   arg2 = (char *)jarg2;
15964   arg3 = (Dali::Property::Value *)jarg3;
15965   if (!arg3) {
15966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15967     return ;
15968   }
15969   {
15970     try {
15971       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15972     } catch (std::out_of_range& e) {
15973       {
15974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15975       };
15976     } catch (std::exception& e) {
15977       {
15978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15979       };
15980     } catch (Dali::DaliException e) {
15981       {
15982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15983       };
15984     } catch (...) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15987       };
15988     }
15989   }
15990
15991 }
15992
15993
15994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15995   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15996   Dali::Property::Index arg2 ;
15997   Dali::Property::Value *arg3 = 0 ;
15998
15999   arg1 = (Dali::Property::Map *)jarg1;
16000   arg2 = (Dali::Property::Index)jarg2;
16001   arg3 = (Dali::Property::Value *)jarg3;
16002   if (!arg3) {
16003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16004     return ;
16005   }
16006   {
16007     try {
16008       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16009     } catch (std::out_of_range& e) {
16010       {
16011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16012       };
16013     } catch (std::exception& e) {
16014       {
16015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16016       };
16017     } catch (Dali::DaliException e) {
16018       {
16019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16020       };
16021     } catch (...) {
16022       {
16023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16024       };
16025     }
16026   }
16027
16028 }
16029
16030
16031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16032   void * jresult ;
16033   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16034   char *arg2 = (char *) 0 ;
16035   Dali::Property::Value *arg3 = 0 ;
16036   Dali::Property::Map *result = 0 ;
16037
16038   arg1 = (Dali::Property::Map *)jarg1;
16039   arg2 = (char *)jarg2;
16040   arg3 = (Dali::Property::Value *)jarg3;
16041   if (!arg3) {
16042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16043     return 0;
16044   }
16045   {
16046     try {
16047       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16048     } catch (std::out_of_range& e) {
16049       {
16050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16051       };
16052     } catch (std::exception& e) {
16053       {
16054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16055       };
16056     } catch (Dali::DaliException e) {
16057       {
16058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16059       };
16060     } catch (...) {
16061       {
16062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16063       };
16064     }
16065   }
16066
16067   jresult = (void *)result;
16068   return jresult;
16069 }
16070
16071
16072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16073   void * jresult ;
16074   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16075   Dali::Property::Index arg2 ;
16076   Dali::Property::Value *arg3 = 0 ;
16077   Dali::Property::Map *result = 0 ;
16078
16079   arg1 = (Dali::Property::Map *)jarg1;
16080   arg2 = (Dali::Property::Index)jarg2;
16081   arg3 = (Dali::Property::Value *)jarg3;
16082   if (!arg3) {
16083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16084     return 0;
16085   }
16086   {
16087     try {
16088       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16089     } catch (std::out_of_range& e) {
16090       {
16091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16092       };
16093     } catch (std::exception& e) {
16094       {
16095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16096       };
16097     } catch (Dali::DaliException e) {
16098       {
16099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16100       };
16101     } catch (...) {
16102       {
16103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16104       };
16105     }
16106   }
16107
16108   jresult = (void *)result;
16109   return jresult;
16110 }
16111
16112
16113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16114   void * jresult ;
16115   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16116   Dali::Property::Map::SizeType arg2 ;
16117   Dali::Property::Value *result = 0 ;
16118
16119   arg1 = (Dali::Property::Map *)jarg1;
16120   arg2 = (Dali::Property::Map::SizeType)jarg2;
16121   {
16122     try {
16123       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16124     } catch (std::out_of_range& e) {
16125       {
16126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16127       };
16128     } catch (std::exception& e) {
16129       {
16130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16131       };
16132     } catch (Dali::DaliException e) {
16133       {
16134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16135       };
16136     } catch (...) {
16137       {
16138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16139       };
16140     }
16141   }
16142
16143   jresult = (void *)result;
16144   return jresult;
16145 }
16146
16147
16148 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16149   char * jresult ;
16150   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16151   Dali::Property::Map::SizeType arg2 ;
16152   std::string *result = 0 ;
16153
16154   arg1 = (Dali::Property::Map *)jarg1;
16155   arg2 = (Dali::Property::Map::SizeType)jarg2;
16156   {
16157     try {
16158       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16159     } catch (std::out_of_range& e) {
16160       {
16161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16162       };
16163     } catch (std::exception& e) {
16164       {
16165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (Dali::DaliException e) {
16168       {
16169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16170       };
16171     } catch (...) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16174       };
16175     }
16176   }
16177
16178   jresult = SWIG_csharp_string_callback(result->c_str());
16179   return jresult;
16180 }
16181
16182
16183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16184   void * jresult ;
16185   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16186   Dali::Property::Map::SizeType arg2 ;
16187   SwigValueWrapper< Dali::Property::Key > result;
16188
16189   arg1 = (Dali::Property::Map *)jarg1;
16190   arg2 = (Dali::Property::Map::SizeType)jarg2;
16191   {
16192     try {
16193       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16194     } catch (std::out_of_range& e) {
16195       {
16196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16197       };
16198     } catch (std::exception& e) {
16199       {
16200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (Dali::DaliException e) {
16203       {
16204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16205       };
16206     } catch (...) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16209       };
16210     }
16211   }
16212
16213   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16214   return jresult;
16215 }
16216
16217
16218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16219   void * jresult ;
16220   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16221   Dali::Property::Map::SizeType arg2 ;
16222   StringValuePair *result = 0 ;
16223
16224   arg1 = (Dali::Property::Map *)jarg1;
16225   arg2 = (Dali::Property::Map::SizeType)jarg2;
16226   {
16227     try {
16228       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16229     } catch (std::out_of_range& e) {
16230       {
16231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16232       };
16233     } catch (std::exception& e) {
16234       {
16235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16236       };
16237     } catch (Dali::DaliException e) {
16238       {
16239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16240       };
16241     } catch (...) {
16242       {
16243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16244       };
16245     }
16246   }
16247
16248   jresult = (void *)result;
16249   return jresult;
16250 }
16251
16252
16253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16254   void * jresult ;
16255   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16256   char *arg2 = (char *) 0 ;
16257   Dali::Property::Value *result = 0 ;
16258
16259   arg1 = (Dali::Property::Map *)jarg1;
16260   arg2 = (char *)jarg2;
16261   {
16262     try {
16263       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16264     } catch (std::out_of_range& e) {
16265       {
16266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (std::exception& e) {
16269       {
16270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16271       };
16272     } catch (Dali::DaliException e) {
16273       {
16274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16275       };
16276     } catch (...) {
16277       {
16278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16279       };
16280     }
16281   }
16282
16283   jresult = (void *)result;
16284   return jresult;
16285 }
16286
16287
16288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16289   void * jresult ;
16290   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16291   Dali::Property::Index arg2 ;
16292   Dali::Property::Value *result = 0 ;
16293
16294   arg1 = (Dali::Property::Map *)jarg1;
16295   arg2 = (Dali::Property::Index)jarg2;
16296   {
16297     try {
16298       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16299     } catch (std::out_of_range& e) {
16300       {
16301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16302       };
16303     } catch (std::exception& e) {
16304       {
16305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16306       };
16307     } catch (Dali::DaliException e) {
16308       {
16309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16310       };
16311     } catch (...) {
16312       {
16313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16314       };
16315     }
16316   }
16317
16318   jresult = (void *)result;
16319   return jresult;
16320 }
16321
16322
16323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16324   void * jresult ;
16325   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16326   Dali::Property::Index arg2 ;
16327   std::string *arg3 = 0 ;
16328   Dali::Property::Value *result = 0 ;
16329
16330   arg1 = (Dali::Property::Map *)jarg1;
16331   arg2 = (Dali::Property::Index)jarg2;
16332   if (!jarg3) {
16333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16334     return 0;
16335   }
16336   std::string arg3_str(jarg3);
16337   arg3 = &arg3_str;
16338   {
16339     try {
16340       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16341     } catch (std::out_of_range& e) {
16342       {
16343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (std::exception& e) {
16346       {
16347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16348       };
16349     } catch (Dali::DaliException e) {
16350       {
16351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16352       };
16353     } catch (...) {
16354       {
16355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16356       };
16357     }
16358   }
16359
16360   jresult = (void *)result;
16361
16362   //argout typemap for const std::string&
16363
16364   return jresult;
16365 }
16366
16367
16368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16369   void * jresult ;
16370   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16371   std::string *arg2 = 0 ;
16372   Dali::Property::Type arg3 ;
16373   Dali::Property::Value *result = 0 ;
16374
16375   arg1 = (Dali::Property::Map *)jarg1;
16376   if (!jarg2) {
16377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16378     return 0;
16379   }
16380   std::string arg2_str(jarg2);
16381   arg2 = &arg2_str;
16382   arg3 = (Dali::Property::Type)jarg3;
16383   {
16384     try {
16385       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16386     } catch (std::out_of_range& e) {
16387       {
16388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16389       };
16390     } catch (std::exception& e) {
16391       {
16392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16393       };
16394     } catch (Dali::DaliException e) {
16395       {
16396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16397       };
16398     } catch (...) {
16399       {
16400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16401       };
16402     }
16403   }
16404
16405   jresult = (void *)result;
16406
16407   //argout typemap for const std::string&
16408
16409   return jresult;
16410 }
16411
16412
16413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16414   void * jresult ;
16415   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16416   Dali::Property::Index arg2 ;
16417   Dali::Property::Type arg3 ;
16418   Dali::Property::Value *result = 0 ;
16419
16420   arg1 = (Dali::Property::Map *)jarg1;
16421   arg2 = (Dali::Property::Index)jarg2;
16422   arg3 = (Dali::Property::Type)jarg3;
16423   {
16424     try {
16425       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16433       };
16434     } catch (Dali::DaliException e) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16437       };
16438     } catch (...) {
16439       {
16440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16441       };
16442     }
16443   }
16444
16445   jresult = (void *)result;
16446   return jresult;
16447 }
16448
16449
16450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16451   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16452
16453   arg1 = (Dali::Property::Map *)jarg1;
16454   {
16455     try {
16456       (arg1)->Clear();
16457     } catch (std::out_of_range& e) {
16458       {
16459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16460       };
16461     } catch (std::exception& e) {
16462       {
16463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16464       };
16465     } catch (Dali::DaliException e) {
16466       {
16467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16468       };
16469     } catch (...) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16472       };
16473     }
16474   }
16475
16476 }
16477
16478
16479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16480   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16481   Dali::Property::Map *arg2 = 0 ;
16482
16483   arg1 = (Dali::Property::Map *)jarg1;
16484   arg2 = (Dali::Property::Map *)jarg2;
16485   if (!arg2) {
16486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16487     return ;
16488   }
16489   {
16490     try {
16491       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16492     } catch (std::out_of_range& e) {
16493       {
16494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16495       };
16496     } catch (std::exception& e) {
16497       {
16498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16499       };
16500     } catch (Dali::DaliException e) {
16501       {
16502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16503       };
16504     } catch (...) {
16505       {
16506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16507       };
16508     }
16509   }
16510
16511 }
16512
16513
16514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16515   void * jresult ;
16516   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16517   std::string *arg2 = 0 ;
16518   Dali::Property::Value *result = 0 ;
16519
16520   arg1 = (Dali::Property::Map *)jarg1;
16521   if (!jarg2) {
16522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16523     return 0;
16524   }
16525   std::string arg2_str(jarg2);
16526   arg2 = &arg2_str;
16527   {
16528     try {
16529       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16530     } catch (std::out_of_range& e) {
16531       {
16532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16533       };
16534     } catch (std::exception& e) {
16535       {
16536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16537       };
16538     } catch (Dali::DaliException e) {
16539       {
16540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16541       };
16542     } catch (...) {
16543       {
16544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16545       };
16546     }
16547   }
16548
16549   jresult = (void *)result;
16550
16551   //argout typemap for const std::string&
16552
16553   return jresult;
16554 }
16555
16556
16557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16558   void * jresult ;
16559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16560   Dali::Property::Index arg2 ;
16561   Dali::Property::Value *result = 0 ;
16562
16563   arg1 = (Dali::Property::Map *)jarg1;
16564   arg2 = (Dali::Property::Index)jarg2;
16565   {
16566     try {
16567       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16568     } catch (std::out_of_range& e) {
16569       {
16570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16571       };
16572     } catch (std::exception& e) {
16573       {
16574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16575       };
16576     } catch (Dali::DaliException e) {
16577       {
16578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16579       };
16580     } catch (...) {
16581       {
16582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16583       };
16584     }
16585   }
16586
16587   jresult = (void *)result;
16588   return jresult;
16589 }
16590
16591
16592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16593   void * jresult ;
16594   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16595   Dali::Property::Map *arg2 = 0 ;
16596   Dali::Property::Map *result = 0 ;
16597
16598   arg1 = (Dali::Property::Map *)jarg1;
16599   arg2 = (Dali::Property::Map *)jarg2;
16600   if (!arg2) {
16601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16602     return 0;
16603   }
16604   {
16605     try {
16606       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16607     } catch (std::out_of_range& e) {
16608       {
16609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16610       };
16611     } catch (std::exception& e) {
16612       {
16613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16614       };
16615     } catch (Dali::DaliException e) {
16616       {
16617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16618       };
16619     } catch (...) {
16620       {
16621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16622       };
16623     }
16624   }
16625
16626   jresult = (void *)result;
16627   return jresult;
16628 }
16629
16630
16631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16632
16633   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16634
16635   if (!jarg2) {
16636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16637     return;
16638   }
16639   std::string arg2_str(jarg2);
16640   std::string* arg2 = &arg2_str;
16641
16642   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16643
16644   {
16645     try {
16646       arg1->operator[]((std::string const &)*arg2) = *arg3;
16647     } catch (std::out_of_range& e) {
16648       {
16649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16650       };
16651     } catch (std::exception& e) {
16652       {
16653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16654       };
16655     } catch (Dali::DaliException e) {
16656       {
16657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16658       };
16659     } catch (...) {
16660       {
16661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16662       };
16663     }
16664   }
16665 }
16666
16667
16668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16669
16670   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16671   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16672   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16673
16674   {
16675     try {
16676       arg1->operator[](arg2) = *arg3;
16677     } catch (std::out_of_range& e) {
16678       {
16679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16680       };
16681     } catch (std::exception& e) {
16682       {
16683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16684       };
16685     } catch (Dali::DaliException e) {
16686       {
16687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16688       };
16689     } catch (...) {
16690       {
16691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16692       };
16693     }
16694   }
16695 }
16696
16697
16698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16699   void * jresult ;
16700   Dali::Property::Value *result = 0 ;
16701
16702   {
16703     try {
16704       result = (Dali::Property::Value *)new Dali::Property::Value();
16705     } catch (std::out_of_range& e) {
16706       {
16707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16708       };
16709     } catch (std::exception& e) {
16710       {
16711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16712       };
16713     } catch (Dali::DaliException e) {
16714       {
16715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16716       };
16717     } catch (...) {
16718       {
16719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16720       };
16721     }
16722   }
16723
16724   jresult = (void *)result;
16725   return jresult;
16726 }
16727
16728
16729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16730   void * jresult ;
16731   bool arg1 ;
16732   Dali::Property::Value *result = 0 ;
16733
16734   arg1 = jarg1 ? true : false;
16735   {
16736     try {
16737       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16738     } catch (std::out_of_range& e) {
16739       {
16740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16741       };
16742     } catch (std::exception& e) {
16743       {
16744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16745       };
16746     } catch (Dali::DaliException e) {
16747       {
16748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16749       };
16750     } catch (...) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16753       };
16754     }
16755   }
16756
16757   jresult = (void *)result;
16758   return jresult;
16759 }
16760
16761
16762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16763   void * jresult ;
16764   int arg1 ;
16765   Dali::Property::Value *result = 0 ;
16766
16767   arg1 = (int)jarg1;
16768   {
16769     try {
16770       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16771     } catch (std::out_of_range& e) {
16772       {
16773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16774       };
16775     } catch (std::exception& e) {
16776       {
16777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16778       };
16779     } catch (Dali::DaliException e) {
16780       {
16781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16782       };
16783     } catch (...) {
16784       {
16785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16786       };
16787     }
16788   }
16789
16790   jresult = (void *)result;
16791   return jresult;
16792 }
16793
16794
16795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16796   void * jresult ;
16797   float arg1 ;
16798   Dali::Property::Value *result = 0 ;
16799
16800   arg1 = (float)jarg1;
16801   {
16802     try {
16803       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16804     } catch (std::out_of_range& e) {
16805       {
16806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16807       };
16808     } catch (std::exception& e) {
16809       {
16810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16811       };
16812     } catch (Dali::DaliException e) {
16813       {
16814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16815       };
16816     } catch (...) {
16817       {
16818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16819       };
16820     }
16821   }
16822
16823   jresult = (void *)result;
16824   return jresult;
16825 }
16826
16827
16828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16829   void * jresult ;
16830   Dali::Vector2 *arg1 = 0 ;
16831   Dali::Property::Value *result = 0 ;
16832
16833   arg1 = (Dali::Vector2 *)jarg1;
16834   if (!arg1) {
16835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16836     return 0;
16837   }
16838   {
16839     try {
16840       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16841     } catch (std::out_of_range& e) {
16842       {
16843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16844       };
16845     } catch (std::exception& e) {
16846       {
16847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16848       };
16849     } catch (Dali::DaliException e) {
16850       {
16851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16852       };
16853     } catch (...) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16856       };
16857     }
16858   }
16859
16860   jresult = (void *)result;
16861   return jresult;
16862 }
16863
16864
16865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16866   void * jresult ;
16867   Dali::Vector3 *arg1 = 0 ;
16868   Dali::Property::Value *result = 0 ;
16869
16870   arg1 = (Dali::Vector3 *)jarg1;
16871   if (!arg1) {
16872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16873     return 0;
16874   }
16875   {
16876     try {
16877       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16878     } catch (std::out_of_range& e) {
16879       {
16880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16881       };
16882     } catch (std::exception& e) {
16883       {
16884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16885       };
16886     } catch (Dali::DaliException e) {
16887       {
16888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16889       };
16890     } catch (...) {
16891       {
16892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16893       };
16894     }
16895   }
16896
16897   jresult = (void *)result;
16898   return jresult;
16899 }
16900
16901
16902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16903   void * jresult ;
16904   Dali::Vector4 *arg1 = 0 ;
16905   Dali::Property::Value *result = 0 ;
16906
16907   arg1 = (Dali::Vector4 *)jarg1;
16908   if (!arg1) {
16909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16910     return 0;
16911   }
16912   {
16913     try {
16914       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16915     } catch (std::out_of_range& e) {
16916       {
16917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16918       };
16919     } catch (std::exception& e) {
16920       {
16921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16922       };
16923     } catch (Dali::DaliException e) {
16924       {
16925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16926       };
16927     } catch (...) {
16928       {
16929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16930       };
16931     }
16932   }
16933
16934   jresult = (void *)result;
16935   return jresult;
16936 }
16937
16938
16939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16940   void * jresult ;
16941   Dali::Matrix3 *arg1 = 0 ;
16942   Dali::Property::Value *result = 0 ;
16943
16944   arg1 = (Dali::Matrix3 *)jarg1;
16945   if (!arg1) {
16946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16947     return 0;
16948   }
16949   {
16950     try {
16951       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16952     } catch (std::out_of_range& e) {
16953       {
16954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16955       };
16956     } catch (std::exception& e) {
16957       {
16958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (Dali::DaliException e) {
16961       {
16962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16963       };
16964     } catch (...) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16967       };
16968     }
16969   }
16970
16971   jresult = (void *)result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16977   void * jresult ;
16978   Dali::Matrix *arg1 = 0 ;
16979   Dali::Property::Value *result = 0 ;
16980
16981   arg1 = (Dali::Matrix *)jarg1;
16982   if (!arg1) {
16983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16984     return 0;
16985   }
16986   {
16987     try {
16988       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16989     } catch (std::out_of_range& e) {
16990       {
16991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16992       };
16993     } catch (std::exception& e) {
16994       {
16995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (Dali::DaliException e) {
16998       {
16999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17000       };
17001     } catch (...) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17004       };
17005     }
17006   }
17007
17008   jresult = (void *)result;
17009   return jresult;
17010 }
17011
17012
17013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17014   void * jresult ;
17015   Dali::Rect< int > *arg1 = 0 ;
17016   Dali::Property::Value *result = 0 ;
17017
17018   arg1 = (Dali::Rect< int > *)jarg1;
17019   if (!arg1) {
17020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17021     return 0;
17022   }
17023   {
17024     try {
17025       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17026     } catch (std::out_of_range& e) {
17027       {
17028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17029       };
17030     } catch (std::exception& e) {
17031       {
17032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17033       };
17034     } catch (Dali::DaliException e) {
17035       {
17036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17037       };
17038     } catch (...) {
17039       {
17040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17041       };
17042     }
17043   }
17044
17045   jresult = (void *)result;
17046   return jresult;
17047 }
17048
17049
17050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17051   void * jresult ;
17052   Dali::AngleAxis *arg1 = 0 ;
17053   Dali::Property::Value *result = 0 ;
17054
17055   arg1 = (Dali::AngleAxis *)jarg1;
17056   if (!arg1) {
17057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17058     return 0;
17059   }
17060   {
17061     try {
17062       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17063     } catch (std::out_of_range& e) {
17064       {
17065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17066       };
17067     } catch (std::exception& e) {
17068       {
17069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (Dali::DaliException e) {
17072       {
17073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081
17082   jresult = (void *)result;
17083   return jresult;
17084 }
17085
17086
17087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17088   void * jresult ;
17089   Dali::Quaternion *arg1 = 0 ;
17090   Dali::Property::Value *result = 0 ;
17091
17092   arg1 = (Dali::Quaternion *)jarg1;
17093   if (!arg1) {
17094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17095     return 0;
17096   }
17097   {
17098     try {
17099       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17100     } catch (std::out_of_range& e) {
17101       {
17102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17103       };
17104     } catch (std::exception& e) {
17105       {
17106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (Dali::DaliException e) {
17109       {
17110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17111       };
17112     } catch (...) {
17113       {
17114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17115       };
17116     }
17117   }
17118
17119   jresult = (void *)result;
17120   return jresult;
17121 }
17122
17123
17124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17125   void * jresult ;
17126   std::string *arg1 = 0 ;
17127   Dali::Property::Value *result = 0 ;
17128
17129   if (!jarg1) {
17130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17131     return 0;
17132   }
17133   std::string arg1_str(jarg1);
17134   arg1 = &arg1_str;
17135   {
17136     try {
17137       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17138     } catch (std::out_of_range& e) {
17139       {
17140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17141       };
17142     } catch (std::exception& e) {
17143       {
17144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17145       };
17146     } catch (Dali::DaliException e) {
17147       {
17148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17149       };
17150     } catch (...) {
17151       {
17152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17153       };
17154     }
17155   }
17156
17157   jresult = (void *)result;
17158
17159   //argout typemap for const std::string&
17160
17161   return jresult;
17162 }
17163
17164
17165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17166   void * jresult ;
17167   Dali::Property::Array *arg1 = 0 ;
17168   Dali::Property::Value *result = 0 ;
17169
17170   arg1 = (Dali::Property::Array *)jarg1;
17171   if (!arg1) {
17172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17173     return 0;
17174   }
17175   {
17176     try {
17177       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17178     } catch (std::out_of_range& e) {
17179       {
17180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17181       };
17182     } catch (std::exception& e) {
17183       {
17184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (Dali::DaliException e) {
17187       {
17188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17189       };
17190     } catch (...) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17193       };
17194     }
17195   }
17196
17197   jresult = (void *)result;
17198   return jresult;
17199 }
17200
17201
17202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17203   void * jresult ;
17204   Dali::Property::Map *arg1 = 0 ;
17205   Dali::Property::Value *result = 0 ;
17206
17207   arg1 = (Dali::Property::Map *)jarg1;
17208   if (!arg1) {
17209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17210     return 0;
17211   }
17212   {
17213     try {
17214       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17215     } catch (std::out_of_range& e) {
17216       {
17217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (std::exception& e) {
17220       {
17221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (Dali::DaliException e) {
17224       {
17225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17226       };
17227     } catch (...) {
17228       {
17229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17230       };
17231     }
17232   }
17233
17234   jresult = (void *)result;
17235   return jresult;
17236 }
17237
17238
17239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17240   void * jresult ;
17241   Extents *arg1 = 0 ;
17242   Dali::Property::Value *result = 0 ;
17243
17244   arg1 = (Extents *)jarg1;
17245   if (!arg1) {
17246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17247     return 0;
17248   }
17249   {
17250     try {
17251       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17252     } catch (std::out_of_range& e) {
17253       {
17254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17255       };
17256     } catch (std::exception& e) {
17257       {
17258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17259       };
17260     } catch (...) {
17261       {
17262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17263       };
17264     }
17265   }
17266   jresult = (void *)result;
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17272   void * jresult ;
17273   Dali::Property::Type arg1 ;
17274   Dali::Property::Value *result = 0 ;
17275
17276   arg1 = (Dali::Property::Type)jarg1;
17277   {
17278     try {
17279       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17280     } catch (std::out_of_range& e) {
17281       {
17282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17283       };
17284     } catch (std::exception& e) {
17285       {
17286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17287       };
17288     } catch (Dali::DaliException e) {
17289       {
17290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17291       };
17292     } catch (...) {
17293       {
17294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17295       };
17296     }
17297   }
17298
17299   jresult = (void *)result;
17300   return jresult;
17301 }
17302
17303
17304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17305   void * jresult ;
17306   Dali::Property::Value *arg1 = 0 ;
17307   Dali::Property::Value *result = 0 ;
17308
17309   arg1 = (Dali::Property::Value *)jarg1;
17310   if (!arg1) {
17311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17312     return 0;
17313   }
17314   {
17315     try {
17316       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17317     } catch (std::out_of_range& e) {
17318       {
17319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17320       };
17321     } catch (std::exception& e) {
17322       {
17323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17324       };
17325     } catch (Dali::DaliException e) {
17326       {
17327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17328       };
17329     } catch (...) {
17330       {
17331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17332       };
17333     }
17334   }
17335
17336   jresult = (void *)result;
17337   return jresult;
17338 }
17339
17340
17341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17342   void * jresult ;
17343   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17344   Dali::Property::Value *arg2 = 0 ;
17345   Dali::Property::Value *result = 0 ;
17346
17347   arg1 = (Dali::Property::Value *)jarg1;
17348   arg2 = (Dali::Property::Value *)jarg2;
17349   if (!arg2) {
17350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17351     return 0;
17352   }
17353   {
17354     try {
17355       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17356     } catch (std::out_of_range& e) {
17357       {
17358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17359       };
17360     } catch (std::exception& e) {
17361       {
17362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17363       };
17364     } catch (Dali::DaliException e) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17367       };
17368     } catch (...) {
17369       {
17370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17371       };
17372     }
17373   }
17374
17375   jresult = (void *)result;
17376   return jresult;
17377 }
17378
17379
17380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17381   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17382
17383   arg1 = (Dali::Property::Value *)jarg1;
17384   {
17385     try {
17386       delete arg1;
17387     } catch (std::out_of_range& e) {
17388       {
17389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17390       };
17391     } catch (std::exception& e) {
17392       {
17393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17394       };
17395     } catch (Dali::DaliException e) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17402       };
17403     }
17404   }
17405
17406 }
17407
17408
17409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17410   int jresult ;
17411   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17412   Dali::Property::Type result;
17413
17414   arg1 = (Dali::Property::Value *)jarg1;
17415   {
17416     try {
17417       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17418     } catch (std::out_of_range& e) {
17419       {
17420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17421       };
17422     } catch (std::exception& e) {
17423       {
17424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (Dali::DaliException e) {
17427       {
17428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17429       };
17430     } catch (...) {
17431       {
17432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17433       };
17434     }
17435   }
17436
17437   jresult = (int)result;
17438   return jresult;
17439 }
17440
17441
17442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17443   unsigned int jresult ;
17444   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17445   bool *arg2 = 0 ;
17446   bool result;
17447
17448   arg1 = (Dali::Property::Value *)jarg1;
17449   arg2 = (bool *)jarg2;
17450   {
17451     try {
17452       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17453     } catch (std::out_of_range& e) {
17454       {
17455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (std::exception& e) {
17458       {
17459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (Dali::DaliException e) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17464       };
17465     } catch (...) {
17466       {
17467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17468       };
17469     }
17470   }
17471
17472   jresult = result;
17473   return jresult;
17474 }
17475
17476
17477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17478   unsigned int jresult ;
17479   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17480   float *arg2 = 0 ;
17481   bool result;
17482
17483   arg1 = (Dali::Property::Value *)jarg1;
17484   arg2 = (float *)jarg2;
17485   {
17486     try {
17487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17488     } catch (std::out_of_range& e) {
17489       {
17490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (std::exception& e) {
17493       {
17494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (Dali::DaliException e) {
17497       {
17498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17499       };
17500     } catch (...) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17503       };
17504     }
17505   }
17506
17507   jresult = result;
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17513   unsigned int jresult ;
17514   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17515   int *arg2 = 0 ;
17516   bool result;
17517
17518   arg1 = (Dali::Property::Value *)jarg1;
17519   arg2 = (int *)jarg2;
17520   {
17521     try {
17522       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17523     } catch (std::out_of_range& e) {
17524       {
17525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17526       };
17527     } catch (std::exception& e) {
17528       {
17529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17530       };
17531     } catch (Dali::DaliException e) {
17532       {
17533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17534       };
17535     } catch (...) {
17536       {
17537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17538       };
17539     }
17540   }
17541
17542   jresult = result;
17543   return jresult;
17544 }
17545
17546
17547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17548   unsigned int jresult ;
17549   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17550   Dali::Rect< int > *arg2 = 0 ;
17551   bool result;
17552
17553   arg1 = (Dali::Property::Value *)jarg1;
17554   arg2 = (Dali::Rect< int > *)jarg2;
17555   if (!arg2) {
17556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17557     return 0;
17558   }
17559   {
17560     try {
17561       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17562     } catch (std::out_of_range& e) {
17563       {
17564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17565       };
17566     } catch (std::exception& e) {
17567       {
17568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (Dali::DaliException e) {
17571       {
17572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17573       };
17574     } catch (...) {
17575       {
17576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17577       };
17578     }
17579   }
17580
17581   jresult = result;
17582   return jresult;
17583 }
17584
17585
17586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17587   unsigned int jresult ;
17588   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17589   Dali::Vector2 *arg2 = 0 ;
17590   bool result;
17591
17592   arg1 = (Dali::Property::Value *)jarg1;
17593   arg2 = (Dali::Vector2 *)jarg2;
17594   if (!arg2) {
17595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17596     return 0;
17597   }
17598   {
17599     try {
17600       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17601     } catch (std::out_of_range& e) {
17602       {
17603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (std::exception& e) {
17606       {
17607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (Dali::DaliException e) {
17610       {
17611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17612       };
17613     } catch (...) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17616       };
17617     }
17618   }
17619
17620   jresult = result;
17621   return jresult;
17622 }
17623
17624
17625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17626   unsigned int jresult ;
17627   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17628   Dali::Vector3 *arg2 = 0 ;
17629   bool result;
17630
17631   arg1 = (Dali::Property::Value *)jarg1;
17632   arg2 = (Dali::Vector3 *)jarg2;
17633   if (!arg2) {
17634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17635     return 0;
17636   }
17637   {
17638     try {
17639       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17640     } catch (std::out_of_range& e) {
17641       {
17642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17643       };
17644     } catch (std::exception& e) {
17645       {
17646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17647       };
17648     } catch (Dali::DaliException e) {
17649       {
17650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17651       };
17652     } catch (...) {
17653       {
17654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17655       };
17656     }
17657   }
17658
17659   jresult = result;
17660   return jresult;
17661 }
17662
17663
17664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17665   unsigned int jresult ;
17666   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17667   Dali::Vector4 *arg2 = 0 ;
17668   bool result;
17669
17670   arg1 = (Dali::Property::Value *)jarg1;
17671   arg2 = (Dali::Vector4 *)jarg2;
17672   if (!arg2) {
17673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17674     return 0;
17675   }
17676   {
17677     try {
17678       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17679     } catch (std::out_of_range& e) {
17680       {
17681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17682       };
17683     } catch (std::exception& e) {
17684       {
17685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (Dali::DaliException e) {
17688       {
17689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17690       };
17691     } catch (...) {
17692       {
17693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17694       };
17695     }
17696   }
17697
17698   jresult = result;
17699   return jresult;
17700 }
17701
17702
17703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17704   unsigned int jresult ;
17705   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17706   Dali::Matrix3 *arg2 = 0 ;
17707   bool result;
17708
17709   arg1 = (Dali::Property::Value *)jarg1;
17710   arg2 = (Dali::Matrix3 *)jarg2;
17711   if (!arg2) {
17712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17713     return 0;
17714   }
17715   {
17716     try {
17717       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17718     } catch (std::out_of_range& e) {
17719       {
17720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17721       };
17722     } catch (std::exception& e) {
17723       {
17724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17725       };
17726     } catch (Dali::DaliException e) {
17727       {
17728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17729       };
17730     } catch (...) {
17731       {
17732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17733       };
17734     }
17735   }
17736
17737   jresult = result;
17738   return jresult;
17739 }
17740
17741
17742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17743   unsigned int jresult ;
17744   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17745   Dali::Matrix *arg2 = 0 ;
17746   bool result;
17747
17748   arg1 = (Dali::Property::Value *)jarg1;
17749   arg2 = (Dali::Matrix *)jarg2;
17750   if (!arg2) {
17751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17752     return 0;
17753   }
17754   {
17755     try {
17756       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17757     } catch (std::out_of_range& e) {
17758       {
17759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17760       };
17761     } catch (std::exception& e) {
17762       {
17763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (Dali::DaliException e) {
17766       {
17767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17768       };
17769     } catch (...) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17772       };
17773     }
17774   }
17775
17776   jresult = result;
17777   return jresult;
17778 }
17779
17780
17781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17782   unsigned int jresult ;
17783   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17784   Dali::AngleAxis *arg2 = 0 ;
17785   bool result;
17786
17787   arg1 = (Dali::Property::Value *)jarg1;
17788   arg2 = (Dali::AngleAxis *)jarg2;
17789   if (!arg2) {
17790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17791     return 0;
17792   }
17793   {
17794     try {
17795       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17796     } catch (std::out_of_range& e) {
17797       {
17798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17799       };
17800     } catch (std::exception& e) {
17801       {
17802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17803       };
17804     } catch (Dali::DaliException e) {
17805       {
17806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17807       };
17808     } catch (...) {
17809       {
17810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17811       };
17812     }
17813   }
17814
17815   jresult = result;
17816   return jresult;
17817 }
17818
17819
17820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17821   unsigned int jresult ;
17822   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17823   Dali::Quaternion *arg2 = 0 ;
17824   bool result;
17825
17826   arg1 = (Dali::Property::Value *)jarg1;
17827   arg2 = (Dali::Quaternion *)jarg2;
17828   if (!arg2) {
17829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17830     return 0;
17831   }
17832   {
17833     try {
17834       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17835     } catch (std::out_of_range& e) {
17836       {
17837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17838       };
17839     } catch (std::exception& e) {
17840       {
17841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17842       };
17843     } catch (Dali::DaliException e) {
17844       {
17845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17846       };
17847     } catch (...) {
17848       {
17849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17850       };
17851     }
17852   }
17853
17854   jresult = result;
17855   return jresult;
17856 }
17857
17858
17859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17860   unsigned int jresult ;
17861   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17862   std::string *arg2 = 0 ;
17863   bool result;
17864
17865   arg1 = (Dali::Property::Value *)jarg1;
17866
17867   //typemap in
17868   std::string temp;
17869   arg2 = &temp;
17870
17871   {
17872     try {
17873       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17874     } catch (std::out_of_range& e) {
17875       {
17876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17877       };
17878     } catch (std::exception& e) {
17879       {
17880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17881       };
17882     } catch (Dali::DaliException e) {
17883       {
17884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17885       };
17886     } catch (...) {
17887       {
17888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17889       };
17890     }
17891   }
17892
17893   jresult = result;
17894
17895   //Typemap argout in c++ file.
17896   //This will convert c++ string to c# string
17897   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17898
17899   return jresult;
17900 }
17901
17902
17903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17904   unsigned int jresult ;
17905   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17906   Dali::Property::Array *arg2 = 0 ;
17907   bool result;
17908
17909   arg1 = (Dali::Property::Value *)jarg1;
17910   arg2 = (Dali::Property::Array *)jarg2;
17911   if (!arg2) {
17912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17913     return 0;
17914   }
17915   {
17916     try {
17917       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17918     } catch (std::out_of_range& e) {
17919       {
17920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17921       };
17922     } catch (std::exception& e) {
17923       {
17924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17925       };
17926     } catch (Dali::DaliException e) {
17927       {
17928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17929       };
17930     } catch (...) {
17931       {
17932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17933       };
17934     }
17935   }
17936
17937   jresult = result;
17938   return jresult;
17939 }
17940
17941
17942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17943   unsigned int jresult ;
17944   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17945   Dali::Property::Map *arg2 = 0 ;
17946   bool result;
17947
17948   arg1 = (Dali::Property::Value *)jarg1;
17949   arg2 = (Dali::Property::Map *)jarg2;
17950   if (!arg2) {
17951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17952     return 0;
17953   }
17954   {
17955     try {
17956       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17957     } catch (std::out_of_range& e) {
17958       {
17959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17960       };
17961     } catch (std::exception& e) {
17962       {
17963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17964       };
17965     } catch (Dali::DaliException e) {
17966       {
17967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17968       };
17969     } catch (...) {
17970       {
17971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17972       };
17973     }
17974   }
17975
17976   jresult = result;
17977   return jresult;
17978 }
17979
17980
17981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17982   unsigned int jresult ;
17983   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17984   Extents *arg2 = 0 ;
17985   bool result;
17986
17987   arg1 = (Dali::Property::Value *)jarg1;
17988   arg2 = (Extents *)jarg2;
17989   if (!arg2) {
17990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17991     return 0;
17992   }
17993   {
17994     try {
17995       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17996     } catch (std::out_of_range& e) {
17997       {
17998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17999       };
18000     } catch (std::exception& e) {
18001       {
18002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18003       };
18004     } catch (...) {
18005       {
18006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18007       };
18008     }
18009   }
18010   jresult = result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18016   void * jresult ;
18017   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18018   Dali::Property::Array *result = 0 ;
18019
18020   arg1 = (Dali::Property::Value *)jarg1;
18021   {
18022     try {
18023       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18024     } catch (std::out_of_range& e) {
18025       {
18026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18027       };
18028     } catch (std::exception& e) {
18029       {
18030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18031       };
18032     } catch (Dali::DaliException e) {
18033       {
18034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18035       };
18036     } catch (...) {
18037       {
18038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18039       };
18040     }
18041   }
18042
18043   jresult = (void *)result;
18044   return jresult;
18045 }
18046
18047
18048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18049   void * jresult ;
18050   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18051   Dali::Property::Map *result = 0 ;
18052
18053   arg1 = (Dali::Property::Value *)jarg1;
18054   {
18055     try {
18056       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18057     } catch (std::out_of_range& e) {
18058       {
18059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18060       };
18061     } catch (std::exception& e) {
18062       {
18063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18064       };
18065     } catch (Dali::DaliException e) {
18066       {
18067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18068       };
18069     } catch (...) {
18070       {
18071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18072       };
18073     }
18074   }
18075
18076   jresult = (void *)result;
18077   return jresult;
18078 }
18079
18080
18081 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18082   char * jresult ;
18083   Dali::Property::Type arg1 ;
18084   char *result = 0 ;
18085
18086   arg1 = (Dali::Property::Type)jarg1;
18087   {
18088     try {
18089       result = (char *)Dali::PropertyTypes::GetName(arg1);
18090     } catch (std::out_of_range& e) {
18091       {
18092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18093       };
18094     } catch (std::exception& e) {
18095       {
18096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18097       };
18098     } catch (Dali::DaliException e) {
18099       {
18100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18101       };
18102     } catch (...) {
18103       {
18104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18105       };
18106     }
18107   }
18108
18109   jresult = SWIG_csharp_string_callback((const char *)result);
18110   return jresult;
18111 }
18112
18113
18114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18115   unsigned int jresult ;
18116   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18117   std::string *arg2 = 0 ;
18118   Dali::Property::Map *arg3 = 0 ;
18119   bool result;
18120
18121   arg1 = (Dali::BaseObject *)jarg1;
18122   if (!jarg2) {
18123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18124     return 0;
18125   }
18126   std::string arg2_str(jarg2);
18127   arg2 = &arg2_str;
18128   arg3 = (Dali::Property::Map *)jarg3;
18129   if (!arg3) {
18130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18131     return 0;
18132   }
18133   {
18134     try {
18135       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18136     } catch (std::out_of_range& e) {
18137       {
18138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18139       };
18140     } catch (std::exception& e) {
18141       {
18142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18143       };
18144     } catch (Dali::DaliException e) {
18145       {
18146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18147       };
18148     } catch (...) {
18149       {
18150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18151       };
18152     }
18153   }
18154
18155   jresult = result;
18156
18157   //argout typemap for const std::string&
18158
18159   return jresult;
18160 }
18161
18162
18163 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18164   char * jresult ;
18165   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18166   std::string *result = 0 ;
18167
18168   arg1 = (Dali::BaseObject *)jarg1;
18169   {
18170     try {
18171       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18172     } catch (std::out_of_range& e) {
18173       {
18174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18175       };
18176     } catch (std::exception& e) {
18177       {
18178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18179       };
18180     } catch (Dali::DaliException e) {
18181       {
18182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18183       };
18184     } catch (...) {
18185       {
18186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18187       };
18188     }
18189   }
18190
18191   jresult = SWIG_csharp_string_callback(result->c_str());
18192   return jresult;
18193 }
18194
18195
18196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18197   unsigned int jresult ;
18198   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18199   Dali::TypeInfo *arg2 = 0 ;
18200   bool result;
18201
18202   arg1 = (Dali::BaseObject *)jarg1;
18203   arg2 = (Dali::TypeInfo *)jarg2;
18204   if (!arg2) {
18205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18206     return 0;
18207   }
18208   {
18209     try {
18210       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18211     } catch (std::out_of_range& e) {
18212       {
18213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18214       };
18215     } catch (std::exception& e) {
18216       {
18217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18218       };
18219     } catch (Dali::DaliException e) {
18220       {
18221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18222       };
18223     } catch (...) {
18224       {
18225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18226       };
18227     }
18228   }
18229
18230   jresult = result;
18231   return jresult;
18232 }
18233
18234
18235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18236   unsigned int jresult ;
18237   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18238   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18239   std::string *arg3 = 0 ;
18240   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18241   bool result;
18242
18243   arg1 = (Dali::BaseObject *)jarg1;
18244   arg2 = (ConnectionTrackerInterface *)jarg2;
18245   if (!jarg3) {
18246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18247     return 0;
18248   }
18249   std::string arg3_str(jarg3);
18250   arg3 = &arg3_str;
18251   arg4 = (FunctorDelegate *)jarg4;
18252   {
18253     try {
18254       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18255     } catch (std::out_of_range& e) {
18256       {
18257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18258       };
18259     } catch (std::exception& e) {
18260       {
18261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18262       };
18263     } catch (Dali::DaliException e) {
18264       {
18265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18266       };
18267     } catch (...) {
18268       {
18269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18270       };
18271     }
18272   }
18273
18274   jresult = result;
18275
18276   //argout typemap for const std::string&
18277
18278   return jresult;
18279 }
18280
18281
18282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18283   void * jresult ;
18284   Dali::BaseHandle *arg1 = 0 ;
18285   Dali::BaseObject *result = 0 ;
18286
18287   arg1 = (Dali::BaseHandle *)jarg1;
18288   if (!arg1) {
18289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18290     return 0;
18291   }
18292   {
18293     try {
18294       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18295     } catch (std::out_of_range& e) {
18296       {
18297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18298       };
18299     } catch (std::exception& e) {
18300       {
18301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18302       };
18303     } catch (Dali::DaliException e) {
18304       {
18305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18306       };
18307     } catch (...) {
18308       {
18309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18310       };
18311     }
18312   }
18313
18314   jresult = (void *)result;
18315   return jresult;
18316 }
18317
18318
18319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18320   void * jresult ;
18321   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18322   Dali::BaseHandle *result = 0 ;
18323
18324   arg1 = (Dali::BaseObject *)jarg1;
18325   {
18326     try {
18327       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18328     } catch (std::out_of_range& e) {
18329       {
18330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (std::exception& e) {
18333       {
18334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18335       };
18336     } catch (Dali::DaliException e) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18339       };
18340     } catch (...) {
18341       {
18342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18343       };
18344     }
18345   }
18346
18347   jresult = (void *)result;
18348   return jresult;
18349 }
18350
18351
18352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18353   void * jresult ;
18354   Dali::BaseHandle *result = 0 ;
18355
18356   {
18357     try {
18358       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18359     } catch (std::out_of_range& e) {
18360       {
18361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18362       };
18363     } catch (std::exception& e) {
18364       {
18365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18366       };
18367     } catch (Dali::DaliException e) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18370       };
18371     } catch (...) {
18372       {
18373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18374       };
18375     }
18376   }
18377
18378   jresult = (void *)result;
18379   return jresult;
18380 }
18381
18382
18383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18384   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18385
18386   arg1 = (Dali::BaseHandle *)jarg1;
18387   {
18388     try {
18389       delete arg1;
18390     } catch (std::out_of_range& e) {
18391       {
18392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18393       };
18394     } catch (std::exception& e) {
18395       {
18396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18397       };
18398     } catch (Dali::DaliException e) {
18399       {
18400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18401       };
18402     } catch (...) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18405       };
18406     }
18407   }
18408
18409 }
18410
18411
18412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18413   void * jresult ;
18414   Dali::BaseHandle *arg1 = 0 ;
18415   Dali::BaseHandle *result = 0 ;
18416
18417   arg1 = (Dali::BaseHandle *)jarg1;
18418   if (!arg1) {
18419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18420     return 0;
18421   }
18422   {
18423     try {
18424       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18425     } catch (std::out_of_range& e) {
18426       {
18427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18428       };
18429     } catch (std::exception& e) {
18430       {
18431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18432       };
18433     } catch (Dali::DaliException e) {
18434       {
18435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18436       };
18437     } catch (...) {
18438       {
18439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18440       };
18441     }
18442   }
18443
18444   jresult = (void *)result;
18445   return jresult;
18446 }
18447
18448
18449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18450   void * jresult ;
18451   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18452   Dali::BaseHandle *arg2 = 0 ;
18453   Dali::BaseHandle *result = 0 ;
18454
18455   arg1 = (Dali::BaseHandle *)jarg1;
18456   arg2 = (Dali::BaseHandle *)jarg2;
18457   if (!arg2) {
18458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18459     return 0;
18460   }
18461   {
18462     try {
18463       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18464     } catch (std::out_of_range& e) {
18465       {
18466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18467       };
18468     } catch (std::exception& e) {
18469       {
18470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18471       };
18472     } catch (Dali::DaliException e) {
18473       {
18474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18479       };
18480     }
18481   }
18482
18483   jresult = (void *)result;
18484   return jresult;
18485 }
18486
18487
18488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18489   unsigned int jresult ;
18490   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18491   std::string *arg2 = 0 ;
18492   Dali::Property::Map *arg3 = 0 ;
18493   bool result;
18494
18495   arg1 = (Dali::BaseHandle *)jarg1;
18496   if (!jarg2) {
18497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18498     return 0;
18499   }
18500   std::string arg2_str(jarg2);
18501   arg2 = &arg2_str;
18502   arg3 = (Dali::Property::Map *)jarg3;
18503   if (!arg3) {
18504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18505     return 0;
18506   }
18507   {
18508     try {
18509       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18510     } catch (std::out_of_range& e) {
18511       {
18512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18513       };
18514     } catch (std::exception& e) {
18515       {
18516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18517       };
18518     } catch (Dali::DaliException e) {
18519       {
18520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18521       };
18522     } catch (...) {
18523       {
18524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18525       };
18526     }
18527   }
18528
18529   jresult = result;
18530
18531   //argout typemap for const std::string&
18532
18533   return jresult;
18534 }
18535
18536
18537 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18538   char * jresult ;
18539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18540   std::string *result = 0 ;
18541
18542   arg1 = (Dali::BaseHandle *)jarg1;
18543   {
18544     try {
18545       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18546     } catch (std::out_of_range& e) {
18547       {
18548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18549       };
18550     } catch (std::exception& e) {
18551       {
18552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18553       };
18554     } catch (Dali::DaliException e) {
18555       {
18556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18557       };
18558     } catch (...) {
18559       {
18560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18561       };
18562     }
18563   }
18564
18565   jresult = SWIG_csharp_string_callback(result->c_str());
18566   return jresult;
18567 }
18568
18569
18570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18571   unsigned int jresult ;
18572   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18573   Dali::TypeInfo *arg2 = 0 ;
18574   bool result;
18575
18576   arg1 = (Dali::BaseHandle *)jarg1;
18577   arg2 = (Dali::TypeInfo *)jarg2;
18578   if (!arg2) {
18579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18580     return 0;
18581   }
18582   {
18583     try {
18584       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18585     } catch (std::out_of_range& e) {
18586       {
18587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18588       };
18589     } catch (std::exception& e) {
18590       {
18591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18592       };
18593     } catch (Dali::DaliException e) {
18594       {
18595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18596       };
18597     } catch (...) {
18598       {
18599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18600       };
18601     }
18602   }
18603
18604   jresult = result;
18605   return jresult;
18606 }
18607
18608
18609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18610   void * jresult ;
18611   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18612   Dali::BaseObject *result = 0 ;
18613
18614   arg1 = (Dali::BaseHandle *)jarg1;
18615   {
18616     try {
18617       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18618     } catch (std::out_of_range& e) {
18619       {
18620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18621       };
18622     } catch (std::exception& e) {
18623       {
18624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18625       };
18626     } catch (Dali::DaliException e) {
18627       {
18628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18629       };
18630     } catch (...) {
18631       {
18632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18633       };
18634     }
18635   }
18636
18637   jresult = (void *)result;
18638   return jresult;
18639 }
18640
18641
18642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18643   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18644
18645   arg1 = (Dali::BaseHandle *)jarg1;
18646   {
18647     try {
18648       (arg1)->Reset();
18649     } catch (std::out_of_range& e) {
18650       {
18651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18652       };
18653     } catch (std::exception& e) {
18654       {
18655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18656       };
18657     } catch (Dali::DaliException e) {
18658       {
18659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18660       };
18661     } catch (...) {
18662       {
18663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18664       };
18665     }
18666   }
18667
18668 }
18669
18670
18671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18672   unsigned int jresult ;
18673   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18674   Dali::BaseHandle *arg2 = 0 ;
18675   bool result;
18676
18677   arg1 = (Dali::BaseHandle *)jarg1;
18678   arg2 = (Dali::BaseHandle *)jarg2;
18679   if (!arg2) {
18680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18681     return 0;
18682   }
18683   {
18684     try {
18685       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18686     } catch (std::out_of_range& e) {
18687       {
18688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18689       };
18690     } catch (std::exception& e) {
18691       {
18692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18693       };
18694     } catch (Dali::DaliException e) {
18695       {
18696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18697       };
18698     } catch (...) {
18699       {
18700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18701       };
18702     }
18703   }
18704
18705   jresult = result;
18706   return jresult;
18707 }
18708
18709
18710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18711   unsigned int jresult ;
18712   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18713   Dali::BaseHandle *arg2 = 0 ;
18714   bool result;
18715
18716   arg1 = (Dali::BaseHandle *)jarg1;
18717   arg2 = (Dali::BaseHandle *)jarg2;
18718   if (!arg2) {
18719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18720     return 0;
18721   }
18722   {
18723     try {
18724       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18725     } catch (std::out_of_range& e) {
18726       {
18727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18728       };
18729     } catch (std::exception& e) {
18730       {
18731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (Dali::DaliException e) {
18734       {
18735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18736       };
18737     } catch (...) {
18738       {
18739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18740       };
18741     }
18742   }
18743
18744   jresult = result;
18745   return jresult;
18746 }
18747
18748
18749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18750   void * jresult ;
18751   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18752   Dali::RefObject *result = 0 ;
18753
18754   arg1 = (Dali::BaseHandle *)jarg1;
18755   {
18756     try {
18757       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18758     } catch (std::out_of_range& e) {
18759       {
18760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18761       };
18762     } catch (std::exception& e) {
18763       {
18764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18765       };
18766     } catch (Dali::DaliException e) {
18767       {
18768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18769       };
18770     } catch (...) {
18771       {
18772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18773       };
18774     }
18775   }
18776
18777   jresult = (void *)result;
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18783   unsigned int jresult ;
18784   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18785   bool result;
18786
18787   arg1 = (Dali::BaseHandle *)jarg1;
18788   {
18789     try {
18790       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18791     } catch (std::out_of_range& e) {
18792       {
18793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (std::exception& e) {
18796       {
18797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (Dali::DaliException e) {
18800       {
18801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18802       };
18803     } catch (...) {
18804       {
18805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18806       };
18807     }
18808   }
18809
18810   jresult = result;
18811   return jresult;
18812 }
18813
18814
18815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18816   unsigned int jresult ;
18817   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18818   Dali::BaseHandle *arg2 = 0 ;
18819   bool result;
18820
18821   arg1 = (Dali::BaseHandle *)jarg1;
18822   arg2 = (Dali::BaseHandle *)jarg2;
18823   if (!arg2) {
18824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18825     return 0;
18826   }
18827   {
18828     try {
18829       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18830     } catch (std::out_of_range& e) {
18831       {
18832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18833       };
18834     } catch (std::exception& e) {
18835       {
18836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18837       };
18838     } catch (Dali::DaliException e) {
18839       {
18840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18841       };
18842     } catch (...) {
18843       {
18844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18845       };
18846     }
18847   }
18848
18849   jresult = result;
18850   return jresult;
18851 }
18852
18853
18854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18855   unsigned int jresult ;
18856   Dali::BaseHandle *arg1 = 0 ;
18857   Dali::BaseHandle *arg2 = 0 ;
18858   bool result;
18859
18860   arg1 = (Dali::BaseHandle *)jarg1;
18861   if (!arg1) {
18862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18863     return 0;
18864   }
18865   arg2 = (Dali::BaseHandle *)jarg2;
18866   if (!arg2) {
18867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18868     return 0;
18869   }
18870   {
18871     try {
18872       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (Dali::DaliException e) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18888       };
18889     }
18890   }
18891
18892   jresult = result;
18893   return jresult;
18894 }
18895
18896
18897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18898   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18899
18900   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18901   {
18902     try {
18903       delete arg1;
18904     } catch (std::out_of_range& e) {
18905       {
18906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18907       };
18908     } catch (std::exception& e) {
18909       {
18910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18911       };
18912     } catch (Dali::DaliException e) {
18913       {
18914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18915       };
18916     } catch (...) {
18917       {
18918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18919       };
18920     }
18921   }
18922
18923 }
18924
18925
18926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18927   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18928   SlotObserver *arg2 = (SlotObserver *) 0 ;
18929   CallbackBase *arg3 = (CallbackBase *) 0 ;
18930
18931   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18932   arg2 = (SlotObserver *)jarg2;
18933   arg3 = (CallbackBase *)jarg3;
18934   {
18935     try {
18936       (arg1)->SignalConnected(arg2,arg3);
18937     } catch (std::out_of_range& e) {
18938       {
18939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18940       };
18941     } catch (std::exception& e) {
18942       {
18943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18944       };
18945     } catch (Dali::DaliException e) {
18946       {
18947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18948       };
18949     } catch (...) {
18950       {
18951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18952       };
18953     }
18954   }
18955
18956 }
18957
18958
18959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18960   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18961
18962   arg1 = (Dali::SignalObserver *)jarg1;
18963   {
18964     try {
18965       delete arg1;
18966     } catch (std::out_of_range& e) {
18967       {
18968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18969       };
18970     } catch (std::exception& e) {
18971       {
18972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18973       };
18974     } catch (Dali::DaliException e) {
18975       {
18976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18977       };
18978     } catch (...) {
18979       {
18980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18981       };
18982     }
18983   }
18984
18985 }
18986
18987
18988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18989   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18990   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18991   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18992
18993   arg1 = (Dali::SignalObserver *)jarg1;
18994   arg2 = (Dali::SlotObserver *)jarg2;
18995   arg3 = (Dali::CallbackBase *)jarg3;
18996   {
18997     try {
18998       (arg1)->SignalDisconnected(arg2,arg3);
18999     } catch (std::out_of_range& e) {
19000       {
19001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19002       };
19003     } catch (std::exception& e) {
19004       {
19005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19006       };
19007     } catch (Dali::DaliException e) {
19008       {
19009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19010       };
19011     } catch (...) {
19012       {
19013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19014       };
19015     }
19016   }
19017
19018 }
19019
19020
19021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19022   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19023
19024   arg1 = (Dali::SlotObserver *)jarg1;
19025   {
19026     try {
19027       delete arg1;
19028     } catch (std::out_of_range& e) {
19029       {
19030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (std::exception& e) {
19033       {
19034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19035       };
19036     } catch (Dali::DaliException e) {
19037       {
19038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19039       };
19040     } catch (...) {
19041       {
19042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19043       };
19044     }
19045   }
19046
19047 }
19048
19049
19050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19051   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19052   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19053
19054   arg1 = (Dali::SlotObserver *)jarg1;
19055   arg2 = (Dali::CallbackBase *)jarg2;
19056   {
19057     try {
19058       (arg1)->SlotDisconnected(arg2);
19059     } catch (std::out_of_range& e) {
19060       {
19061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19062       };
19063     } catch (std::exception& e) {
19064       {
19065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19066       };
19067     } catch (Dali::DaliException e) {
19068       {
19069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19070       };
19071     } catch (...) {
19072       {
19073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19074       };
19075     }
19076   }
19077
19078 }
19079
19080
19081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19082   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19083
19084   arg1 = (Dali::ConnectionTracker *)jarg1;
19085   {
19086     try {
19087       delete arg1;
19088     } catch (std::out_of_range& e) {
19089       {
19090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19091       };
19092     } catch (std::exception& e) {
19093       {
19094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19095       };
19096     } catch (Dali::DaliException e) {
19097       {
19098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19099       };
19100     } catch (...) {
19101       {
19102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19103       };
19104     }
19105   }
19106
19107 }
19108
19109
19110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19111   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19112
19113   arg1 = (Dali::ConnectionTracker *)jarg1;
19114   {
19115     try {
19116       (arg1)->DisconnectAll();
19117     } catch (std::out_of_range& e) {
19118       {
19119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19120       };
19121     } catch (std::exception& e) {
19122       {
19123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19124       };
19125     } catch (Dali::DaliException e) {
19126       {
19127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19128       };
19129     } catch (...) {
19130       {
19131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19132       };
19133     }
19134   }
19135
19136 }
19137
19138
19139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19140   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19141   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19142   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19143
19144   arg1 = (Dali::ConnectionTracker *)jarg1;
19145   arg2 = (Dali::SlotObserver *)jarg2;
19146   arg3 = (Dali::CallbackBase *)jarg3;
19147   {
19148     try {
19149       (arg1)->SignalConnected(arg2,arg3);
19150     } catch (std::out_of_range& e) {
19151       {
19152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19153       };
19154     } catch (std::exception& e) {
19155       {
19156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19157       };
19158     } catch (Dali::DaliException e) {
19159       {
19160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19165       };
19166     }
19167   }
19168
19169 }
19170
19171
19172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19173   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19174   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19175   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19176
19177   arg1 = (Dali::ConnectionTracker *)jarg1;
19178   arg2 = (Dali::SlotObserver *)jarg2;
19179   arg3 = (Dali::CallbackBase *)jarg3;
19180   {
19181     try {
19182       (arg1)->SignalDisconnected(arg2,arg3);
19183     } catch (std::out_of_range& e) {
19184       {
19185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19186       };
19187     } catch (std::exception& e) {
19188       {
19189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19190       };
19191     } catch (Dali::DaliException e) {
19192       {
19193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19194       };
19195     } catch (...) {
19196       {
19197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19198       };
19199     }
19200   }
19201
19202 }
19203
19204
19205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19206   unsigned long jresult ;
19207   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19208   std::size_t result;
19209
19210   arg1 = (Dali::ConnectionTracker *)jarg1;
19211   {
19212     try {
19213       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19214     } catch (std::out_of_range& e) {
19215       {
19216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (std::exception& e) {
19219       {
19220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19221       };
19222     } catch (Dali::DaliException e) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19225       };
19226     } catch (...) {
19227       {
19228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19229       };
19230     }
19231   }
19232
19233   jresult = (unsigned long)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19239   void * jresult ;
19240   Dali::ObjectRegistry *result = 0 ;
19241
19242   {
19243     try {
19244       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19245     } catch (std::out_of_range& e) {
19246       {
19247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19248       };
19249     } catch (std::exception& e) {
19250       {
19251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19252       };
19253     } catch (Dali::DaliException e) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19260       };
19261     }
19262   }
19263
19264   jresult = (void *)result;
19265   return jresult;
19266 }
19267
19268
19269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19270   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19271
19272   arg1 = (Dali::ObjectRegistry *)jarg1;
19273   {
19274     try {
19275       delete arg1;
19276     } catch (std::out_of_range& e) {
19277       {
19278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19279       };
19280     } catch (std::exception& e) {
19281       {
19282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19283       };
19284     } catch (Dali::DaliException e) {
19285       {
19286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19287       };
19288     } catch (...) {
19289       {
19290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19291       };
19292     }
19293   }
19294
19295 }
19296
19297
19298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19299   void * jresult ;
19300   Dali::ObjectRegistry *arg1 = 0 ;
19301   Dali::ObjectRegistry *result = 0 ;
19302
19303   arg1 = (Dali::ObjectRegistry *)jarg1;
19304   if (!arg1) {
19305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19306     return 0;
19307   }
19308   {
19309     try {
19310       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19311     } catch (std::out_of_range& e) {
19312       {
19313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19314       };
19315     } catch (std::exception& e) {
19316       {
19317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (Dali::DaliException e) {
19320       {
19321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329
19330   jresult = (void *)result;
19331   return jresult;
19332 }
19333
19334
19335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19336   void * jresult ;
19337   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19338   Dali::ObjectRegistry *arg2 = 0 ;
19339   Dali::ObjectRegistry *result = 0 ;
19340
19341   arg1 = (Dali::ObjectRegistry *)jarg1;
19342   arg2 = (Dali::ObjectRegistry *)jarg2;
19343   if (!arg2) {
19344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19345     return 0;
19346   }
19347   {
19348     try {
19349       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19350     } catch (std::out_of_range& e) {
19351       {
19352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19353       };
19354     } catch (std::exception& e) {
19355       {
19356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19357       };
19358     } catch (Dali::DaliException e) {
19359       {
19360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19361       };
19362     } catch (...) {
19363       {
19364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19365       };
19366     }
19367   }
19368
19369   jresult = (void *)result;
19370   return jresult;
19371 }
19372
19373
19374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19375   void * jresult ;
19376   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19377   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19378
19379   arg1 = (Dali::ObjectRegistry *)jarg1;
19380   {
19381     try {
19382       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19383     } catch (std::out_of_range& e) {
19384       {
19385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19386       };
19387     } catch (std::exception& e) {
19388       {
19389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19390       };
19391     } catch (Dali::DaliException e) {
19392       {
19393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19394       };
19395     } catch (...) {
19396       {
19397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19398       };
19399     }
19400   }
19401
19402   jresult = (void *)result;
19403   return jresult;
19404 }
19405
19406
19407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19408   void * jresult ;
19409   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19410   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19411
19412   arg1 = (Dali::ObjectRegistry *)jarg1;
19413   {
19414     try {
19415       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19416     } catch (std::out_of_range& e) {
19417       {
19418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19419       };
19420     } catch (std::exception& e) {
19421       {
19422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19423       };
19424     } catch (Dali::DaliException e) {
19425       {
19426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19427       };
19428     } catch (...) {
19429       {
19430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19431       };
19432     }
19433   }
19434
19435   jresult = (void *)result;
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19441   void * jresult ;
19442   Dali::PropertyCondition *result = 0 ;
19443
19444   {
19445     try {
19446       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19447     } catch (std::out_of_range& e) {
19448       {
19449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19450       };
19451     } catch (std::exception& e) {
19452       {
19453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19454       };
19455     } catch (Dali::DaliException e) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19458       };
19459     } catch (...) {
19460       {
19461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19462       };
19463     }
19464   }
19465
19466   jresult = (void *)result;
19467   return jresult;
19468 }
19469
19470
19471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19472   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19473
19474   arg1 = (Dali::PropertyCondition *)jarg1;
19475   {
19476     try {
19477       delete arg1;
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (Dali::DaliException e) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19489       };
19490     } catch (...) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19493       };
19494     }
19495   }
19496
19497 }
19498
19499
19500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19501   void * jresult ;
19502   Dali::PropertyCondition *arg1 = 0 ;
19503   Dali::PropertyCondition *result = 0 ;
19504
19505   arg1 = (Dali::PropertyCondition *)jarg1;
19506   if (!arg1) {
19507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19508     return 0;
19509   }
19510   {
19511     try {
19512       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19513     } catch (std::out_of_range& e) {
19514       {
19515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19516       };
19517     } catch (std::exception& e) {
19518       {
19519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (Dali::DaliException e) {
19522       {
19523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19524       };
19525     } catch (...) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19528       };
19529     }
19530   }
19531
19532   jresult = (void *)result;
19533   return jresult;
19534 }
19535
19536
19537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19538   void * jresult ;
19539   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19540   Dali::PropertyCondition *arg2 = 0 ;
19541   Dali::PropertyCondition *result = 0 ;
19542
19543   arg1 = (Dali::PropertyCondition *)jarg1;
19544   arg2 = (Dali::PropertyCondition *)jarg2;
19545   if (!arg2) {
19546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19547     return 0;
19548   }
19549   {
19550     try {
19551       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19552     } catch (std::out_of_range& e) {
19553       {
19554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19555       };
19556     } catch (std::exception& e) {
19557       {
19558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (Dali::DaliException e) {
19561       {
19562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19567       };
19568     }
19569   }
19570
19571   jresult = (void *)result;
19572   return jresult;
19573 }
19574
19575
19576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19577   unsigned long jresult ;
19578   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19579   std::size_t result;
19580
19581   arg1 = (Dali::PropertyCondition *)jarg1;
19582   {
19583     try {
19584       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19585     } catch (std::out_of_range& e) {
19586       {
19587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19588       };
19589     } catch (std::exception& e) {
19590       {
19591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19592       };
19593     } catch (...) {
19594       {
19595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19596       };
19597     }
19598   }
19599   jresult = (unsigned long)result;
19600   return jresult;
19601 }
19602
19603
19604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19605   float jresult ;
19606   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19607   std::size_t arg2 ;
19608   float result;
19609
19610   arg1 = (Dali::PropertyCondition *)jarg1;
19611   arg2 = (std::size_t)jarg2;
19612   {
19613     try {
19614       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19615     } catch (std::out_of_range& e) {
19616       {
19617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19618       };
19619     } catch (std::exception& e) {
19620       {
19621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19622       };
19623     } catch (...) {
19624       {
19625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19626       };
19627     }
19628   }
19629   jresult = result;
19630   return jresult;
19631 }
19632
19633
19634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19635   void * jresult ;
19636   float arg1 ;
19637   Dali::PropertyCondition result;
19638
19639   arg1 = (float)jarg1;
19640   {
19641     try {
19642       result = Dali::LessThanCondition(arg1);
19643     } catch (std::out_of_range& e) {
19644       {
19645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19646       };
19647     } catch (std::exception& e) {
19648       {
19649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19650       };
19651     } catch (Dali::DaliException e) {
19652       {
19653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19654       };
19655     } catch (...) {
19656       {
19657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19658       };
19659     }
19660   }
19661
19662   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19663   return jresult;
19664 }
19665
19666
19667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19668   void * jresult ;
19669   float arg1 ;
19670   Dali::PropertyCondition result;
19671
19672   arg1 = (float)jarg1;
19673   {
19674     try {
19675       result = Dali::GreaterThanCondition(arg1);
19676     } catch (std::out_of_range& e) {
19677       {
19678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19679       };
19680     } catch (std::exception& e) {
19681       {
19682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (Dali::DaliException e) {
19685       {
19686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19687       };
19688     } catch (...) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19691       };
19692     }
19693   }
19694
19695   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19701   void * jresult ;
19702   float arg1 ;
19703   float arg2 ;
19704   Dali::PropertyCondition result;
19705
19706   arg1 = (float)jarg1;
19707   arg2 = (float)jarg2;
19708   {
19709     try {
19710       result = Dali::InsideCondition(arg1,arg2);
19711     } catch (std::out_of_range& e) {
19712       {
19713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19714       };
19715     } catch (std::exception& e) {
19716       {
19717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (Dali::DaliException e) {
19720       {
19721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19726       };
19727     }
19728   }
19729
19730   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19731   return jresult;
19732 }
19733
19734
19735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19736   void * jresult ;
19737   float arg1 ;
19738   float arg2 ;
19739   Dali::PropertyCondition result;
19740
19741   arg1 = (float)jarg1;
19742   arg2 = (float)jarg2;
19743   {
19744     try {
19745       result = Dali::OutsideCondition(arg1,arg2);
19746     } catch (std::out_of_range& e) {
19747       {
19748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19749       };
19750     } catch (std::exception& e) {
19751       {
19752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (Dali::DaliException e) {
19755       {
19756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19757       };
19758     } catch (...) {
19759       {
19760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19761       };
19762     }
19763   }
19764
19765   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19766   return jresult;
19767 }
19768
19769
19770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19771   void * jresult ;
19772   float arg1 ;
19773   float arg2 ;
19774   Dali::PropertyCondition result;
19775
19776   arg1 = (float)jarg1;
19777   arg2 = (float)jarg2;
19778   {
19779     try {
19780       result = Dali::StepCondition(arg1,arg2);
19781     } catch (std::out_of_range& e) {
19782       {
19783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19784       };
19785     } catch (std::exception& e) {
19786       {
19787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19788       };
19789     } catch (Dali::DaliException e) {
19790       {
19791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19792       };
19793     } catch (...) {
19794       {
19795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19796       };
19797     }
19798   }
19799
19800   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19801   return jresult;
19802 }
19803
19804
19805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19806   void * jresult ;
19807   float arg1 ;
19808   Dali::PropertyCondition result;
19809
19810   arg1 = (float)jarg1;
19811   {
19812     try {
19813       result = Dali::StepCondition(arg1);
19814     } catch (std::out_of_range& e) {
19815       {
19816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19817       };
19818     } catch (std::exception& e) {
19819       {
19820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19821       };
19822     } catch (Dali::DaliException e) {
19823       {
19824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19825       };
19826     } catch (...) {
19827       {
19828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19829       };
19830     }
19831   }
19832
19833   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19834   return jresult;
19835 }
19836
19837
19838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19839   void * jresult ;
19840   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19841   Dali::PropertyCondition result;
19842
19843   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19844   if (!arg1) {
19845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19846     return 0;
19847   }
19848   {
19849     try {
19850       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19851     } catch (std::out_of_range& e) {
19852       {
19853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (std::exception& e) {
19856       {
19857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19858       };
19859     } catch (Dali::DaliException e) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19862       };
19863     } catch (...) {
19864       {
19865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19866       };
19867     }
19868   }
19869
19870   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19871   return jresult;
19872 }
19873
19874
19875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19876   void * jresult ;
19877   Dali::PropertyNotification *result = 0 ;
19878
19879   {
19880     try {
19881       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19882     } catch (std::out_of_range& e) {
19883       {
19884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19885       };
19886     } catch (std::exception& e) {
19887       {
19888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19889       };
19890     } catch (Dali::DaliException e) {
19891       {
19892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19893       };
19894     } catch (...) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19897       };
19898     }
19899   }
19900
19901   jresult = (void *)result;
19902   return jresult;
19903 }
19904
19905
19906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19907   void * jresult ;
19908   Dali::BaseHandle arg1 ;
19909   Dali::BaseHandle *argp1 ;
19910   Dali::PropertyNotification result;
19911
19912   argp1 = (Dali::BaseHandle *)jarg1;
19913   if (!argp1) {
19914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19915     return 0;
19916   }
19917   arg1 = *argp1;
19918   {
19919     try {
19920       result = Dali::PropertyNotification::DownCast(arg1);
19921     } catch (std::out_of_range& e) {
19922       {
19923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19924       };
19925     } catch (std::exception& e) {
19926       {
19927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19928       };
19929     } catch (Dali::DaliException e) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19932       };
19933     } catch (...) {
19934       {
19935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19936       };
19937     }
19938   }
19939
19940   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19941   return jresult;
19942 }
19943
19944
19945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19946   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19947
19948   arg1 = (Dali::PropertyNotification *)jarg1;
19949   {
19950     try {
19951       delete arg1;
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19959       };
19960     } catch (Dali::DaliException e) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19963       };
19964     } catch (...) {
19965       {
19966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19967       };
19968     }
19969   }
19970
19971 }
19972
19973
19974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19975   void * jresult ;
19976   Dali::PropertyNotification *arg1 = 0 ;
19977   Dali::PropertyNotification *result = 0 ;
19978
19979   arg1 = (Dali::PropertyNotification *)jarg1;
19980   if (!arg1) {
19981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19982     return 0;
19983   }
19984   {
19985     try {
19986       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19987     } catch (std::out_of_range& e) {
19988       {
19989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19990       };
19991     } catch (std::exception& e) {
19992       {
19993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19994       };
19995     } catch (Dali::DaliException e) {
19996       {
19997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19998       };
19999     } catch (...) {
20000       {
20001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20002       };
20003     }
20004   }
20005
20006   jresult = (void *)result;
20007   return jresult;
20008 }
20009
20010
20011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20012   void * jresult ;
20013   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20014   Dali::PropertyNotification *arg2 = 0 ;
20015   Dali::PropertyNotification *result = 0 ;
20016
20017   arg1 = (Dali::PropertyNotification *)jarg1;
20018   arg2 = (Dali::PropertyNotification *)jarg2;
20019   if (!arg2) {
20020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20021     return 0;
20022   }
20023   {
20024     try {
20025       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20026     } catch (std::out_of_range& e) {
20027       {
20028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20029       };
20030     } catch (std::exception& e) {
20031       {
20032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20033       };
20034     } catch (Dali::DaliException e) {
20035       {
20036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20037       };
20038     } catch (...) {
20039       {
20040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20041       };
20042     }
20043   }
20044
20045   jresult = (void *)result;
20046   return jresult;
20047 }
20048
20049
20050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20051   void * jresult ;
20052   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20053   Dali::PropertyCondition result;
20054
20055   arg1 = (Dali::PropertyNotification *)jarg1;
20056   {
20057     try {
20058       result = (arg1)->GetCondition();
20059     } catch (std::out_of_range& e) {
20060       {
20061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20062       };
20063     } catch (std::exception& e) {
20064       {
20065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20066       };
20067     } catch (Dali::DaliException e) {
20068       {
20069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20070       };
20071     } catch (...) {
20072       {
20073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20074       };
20075     }
20076   }
20077
20078   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20084   void * jresult ;
20085   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20086   Dali::Handle result;
20087
20088   arg1 = (Dali::PropertyNotification *)jarg1;
20089   {
20090     try {
20091       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20092     } catch (std::out_of_range& e) {
20093       {
20094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20095       };
20096     } catch (std::exception& e) {
20097       {
20098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20099       };
20100     } catch (Dali::DaliException e) {
20101       {
20102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20103       };
20104     } catch (...) {
20105       {
20106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20107       };
20108     }
20109   }
20110
20111   jresult = new Dali::Handle((const Dali::Handle &)result);
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20117   int jresult ;
20118   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20119   Dali::Property::Index result;
20120
20121   arg1 = (Dali::PropertyNotification *)jarg1;
20122   {
20123     try {
20124       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20125     } catch (std::out_of_range& e) {
20126       {
20127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20128       };
20129     } catch (std::exception& e) {
20130       {
20131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20132       };
20133     } catch (Dali::DaliException e) {
20134       {
20135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20136       };
20137     } catch (...) {
20138       {
20139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20140       };
20141     }
20142   }
20143
20144   jresult = result;
20145   return jresult;
20146 }
20147
20148
20149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20150   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20151   Dali::PropertyNotification::NotifyMode arg2 ;
20152
20153   arg1 = (Dali::PropertyNotification *)jarg1;
20154   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20155   {
20156     try {
20157       (arg1)->SetNotifyMode(arg2);
20158     } catch (std::out_of_range& e) {
20159       {
20160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20161       };
20162     } catch (std::exception& e) {
20163       {
20164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20165       };
20166     } catch (Dali::DaliException e) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20169       };
20170     } catch (...) {
20171       {
20172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20173       };
20174     }
20175   }
20176
20177 }
20178
20179
20180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20181   int jresult ;
20182   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20183   Dali::PropertyNotification::NotifyMode result;
20184
20185   arg1 = (Dali::PropertyNotification *)jarg1;
20186   {
20187     try {
20188       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20189     } catch (std::out_of_range& e) {
20190       {
20191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20192       };
20193     } catch (std::exception& e) {
20194       {
20195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20196       };
20197     } catch (Dali::DaliException e) {
20198       {
20199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20200       };
20201     } catch (...) {
20202       {
20203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20204       };
20205     }
20206   }
20207
20208   jresult = (int)result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20214   unsigned int jresult ;
20215   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20216   bool result;
20217
20218   arg1 = (Dali::PropertyNotification *)jarg1;
20219   {
20220     try {
20221       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20222     } catch (std::out_of_range& e) {
20223       {
20224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20225       };
20226     } catch (std::exception& e) {
20227       {
20228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20229       };
20230     } catch (Dali::DaliException e) {
20231       {
20232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20233       };
20234     } catch (...) {
20235       {
20236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20237       };
20238     }
20239   }
20240
20241   jresult = result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20247   void * jresult ;
20248   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20249   Dali::PropertyNotifySignalType *result = 0 ;
20250
20251   arg1 = (Dali::PropertyNotification *)jarg1;
20252   {
20253     try {
20254       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20255     } catch (std::out_of_range& e) {
20256       {
20257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20258       };
20259     } catch (std::exception& e) {
20260       {
20261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20262       };
20263     } catch (Dali::DaliException e) {
20264       {
20265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20266       };
20267     } catch (...) {
20268       {
20269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20270       };
20271     }
20272   }
20273
20274   jresult = (void *)result;
20275   return jresult;
20276 }
20277
20278
20279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20280   void * jresult ;
20281   Dali::Handle *result = 0 ;
20282
20283   {
20284     try {
20285       result = (Dali::Handle *)new Dali::Handle();
20286     } catch (std::out_of_range& e) {
20287       {
20288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20289       };
20290     } catch (std::exception& e) {
20291       {
20292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20293       };
20294     } catch (Dali::DaliException e) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20297       };
20298     } catch (...) {
20299       {
20300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20301       };
20302     }
20303   }
20304
20305   jresult = (void *)result;
20306   return jresult;
20307 }
20308
20309
20310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20311   void * jresult ;
20312   Dali::Handle result;
20313
20314   {
20315     try {
20316       result = Dali::Handle::New();
20317     } catch (std::out_of_range& e) {
20318       {
20319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20320       };
20321     } catch (std::exception& e) {
20322       {
20323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20324       };
20325     } catch (Dali::DaliException e) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20328       };
20329     } catch (...) {
20330       {
20331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20332       };
20333     }
20334   }
20335
20336   jresult = new Dali::Handle((const Dali::Handle &)result);
20337   return jresult;
20338 }
20339
20340
20341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20342   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20343
20344   arg1 = (Dali::Handle *)jarg1;
20345   {
20346     try {
20347       delete arg1;
20348     } catch (std::out_of_range& e) {
20349       {
20350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20351       };
20352     } catch (std::exception& e) {
20353       {
20354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20355       };
20356     } catch (Dali::DaliException e) {
20357       {
20358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20359       };
20360     } catch (...) {
20361       {
20362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20363       };
20364     }
20365   }
20366
20367 }
20368
20369
20370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20371   void * jresult ;
20372   Dali::Handle *arg1 = 0 ;
20373   Dali::Handle *result = 0 ;
20374
20375   arg1 = (Dali::Handle *)jarg1;
20376   if (!arg1) {
20377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20378     return 0;
20379   }
20380   {
20381     try {
20382       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20383     } catch (std::out_of_range& e) {
20384       {
20385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20386       };
20387     } catch (std::exception& e) {
20388       {
20389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20390       };
20391     } catch (Dali::DaliException e) {
20392       {
20393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20394       };
20395     } catch (...) {
20396       {
20397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20398       };
20399     }
20400   }
20401
20402   jresult = (void *)result;
20403   return jresult;
20404 }
20405
20406
20407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20408   void * jresult ;
20409   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20410   Dali::Handle *arg2 = 0 ;
20411   Dali::Handle *result = 0 ;
20412
20413   arg1 = (Dali::Handle *)jarg1;
20414   arg2 = (Dali::Handle *)jarg2;
20415   if (!arg2) {
20416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20417     return 0;
20418   }
20419   {
20420     try {
20421       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20422     } catch (std::out_of_range& e) {
20423       {
20424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20425       };
20426     } catch (std::exception& e) {
20427       {
20428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20429       };
20430     } catch (Dali::DaliException e) {
20431       {
20432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20433       };
20434     } catch (...) {
20435       {
20436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20437       };
20438     }
20439   }
20440
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20447   void * jresult ;
20448   Dali::BaseHandle arg1 ;
20449   Dali::BaseHandle *argp1 ;
20450   Dali::Handle result;
20451
20452   argp1 = (Dali::BaseHandle *)jarg1;
20453   if (!argp1) {
20454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20455     return 0;
20456   }
20457   arg1 = *argp1;
20458   {
20459     try {
20460       result = Dali::Handle::DownCast(arg1);
20461     } catch (std::out_of_range& e) {
20462       {
20463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20464       };
20465     } catch (std::exception& e) {
20466       {
20467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20468       };
20469     } catch (Dali::DaliException e) {
20470       {
20471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20472       };
20473     } catch (...) {
20474       {
20475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20476       };
20477     }
20478   }
20479
20480   jresult = new Dali::Handle((const Dali::Handle &)result);
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20486   unsigned int jresult ;
20487   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20488   Dali::Handle::Capability arg2 ;
20489   bool result;
20490
20491   arg1 = (Dali::Handle *)jarg1;
20492   arg2 = (Dali::Handle::Capability)jarg2;
20493   {
20494     try {
20495       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20496     } catch (std::out_of_range& e) {
20497       {
20498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20499       };
20500     } catch (std::exception& e) {
20501       {
20502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20503       };
20504     } catch (Dali::DaliException e) {
20505       {
20506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20507       };
20508     } catch (...) {
20509       {
20510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20511       };
20512     }
20513   }
20514
20515   jresult = result;
20516   return jresult;
20517 }
20518
20519
20520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20521   unsigned int jresult ;
20522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20523   unsigned int result;
20524
20525   arg1 = (Dali::Handle *)jarg1;
20526   {
20527     try {
20528       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20529     } catch (std::out_of_range& e) {
20530       {
20531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20532       };
20533     } catch (std::exception& e) {
20534       {
20535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (Dali::DaliException e) {
20538       {
20539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20540       };
20541     } catch (...) {
20542       {
20543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20544       };
20545     }
20546   }
20547
20548   jresult = result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20554   char * jresult ;
20555   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20556   Dali::Property::Index arg2 ;
20557   std::string result;
20558
20559   arg1 = (Dali::Handle *)jarg1;
20560   arg2 = (Dali::Property::Index)jarg2;
20561   {
20562     try {
20563       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20564     } catch (std::out_of_range& e) {
20565       {
20566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20567       };
20568     } catch (std::exception& e) {
20569       {
20570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20571       };
20572     } catch (Dali::DaliException e) {
20573       {
20574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20575       };
20576     } catch (...) {
20577       {
20578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20579       };
20580     }
20581   }
20582
20583   jresult = SWIG_csharp_string_callback((&result)->c_str());
20584   return jresult;
20585 }
20586
20587
20588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20589   int jresult ;
20590   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20591   std::string *arg2 = 0 ;
20592   Dali::Property::Index result;
20593
20594   arg1 = (Dali::Handle *)jarg1;
20595   if (!jarg2) {
20596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20597     return 0;
20598   }
20599   std::string arg2_str(jarg2);
20600   arg2 = &arg2_str;
20601   {
20602     try {
20603       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20604     } catch (std::out_of_range& e) {
20605       {
20606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20607       };
20608     } catch (std::exception& e) {
20609       {
20610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20611       };
20612     } catch (Dali::DaliException e) {
20613       {
20614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20615       };
20616     } catch (...) {
20617       {
20618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20619       };
20620     }
20621   }
20622
20623   jresult = result;
20624
20625   //argout typemap for const std::string&
20626
20627   return jresult;
20628 }
20629
20630
20631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20632   unsigned int jresult ;
20633   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20634   Dali::Property::Index arg2 ;
20635   bool result;
20636
20637   arg1 = (Dali::Handle *)jarg1;
20638   arg2 = (Dali::Property::Index)jarg2;
20639   {
20640     try {
20641       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (Dali::DaliException e) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20653       };
20654     } catch (...) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20657       };
20658     }
20659   }
20660
20661   jresult = result;
20662   return jresult;
20663 }
20664
20665
20666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20667   unsigned int jresult ;
20668   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20669   Dali::Property::Index arg2 ;
20670   bool result;
20671
20672   arg1 = (Dali::Handle *)jarg1;
20673   arg2 = (Dali::Property::Index)jarg2;
20674   {
20675     try {
20676       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20677     } catch (std::out_of_range& e) {
20678       {
20679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (std::exception& e) {
20682       {
20683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (Dali::DaliException e) {
20686       {
20687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20688       };
20689     } catch (...) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20692       };
20693     }
20694   }
20695
20696   jresult = result;
20697   return jresult;
20698 }
20699
20700
20701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20702   unsigned int jresult ;
20703   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20704   Dali::Property::Index arg2 ;
20705   bool result;
20706
20707   arg1 = (Dali::Handle *)jarg1;
20708   arg2 = (Dali::Property::Index)jarg2;
20709   {
20710     try {
20711       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20712     } catch (std::out_of_range& e) {
20713       {
20714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20715       };
20716     } catch (std::exception& e) {
20717       {
20718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (Dali::DaliException e) {
20721       {
20722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730
20731   jresult = result;
20732   return jresult;
20733 }
20734
20735
20736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20737   int jresult ;
20738   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20739   Dali::Property::Index arg2 ;
20740   Dali::Property::Type result;
20741
20742   arg1 = (Dali::Handle *)jarg1;
20743   arg2 = (Dali::Property::Index)jarg2;
20744   {
20745     try {
20746       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20747     } catch (std::out_of_range& e) {
20748       {
20749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20750       };
20751     } catch (std::exception& e) {
20752       {
20753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20754       };
20755     } catch (Dali::DaliException e) {
20756       {
20757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20758       };
20759     } catch (...) {
20760       {
20761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20762       };
20763     }
20764   }
20765
20766   jresult = (int)result;
20767   return jresult;
20768 }
20769
20770
20771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20772   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20773   Dali::Property::Index arg2 ;
20774   Dali::Property::Value *arg3 = 0 ;
20775
20776   arg1 = (Dali::Handle *)jarg1;
20777   arg2 = (Dali::Property::Index)jarg2;
20778   arg3 = (Dali::Property::Value *)jarg3;
20779   if (!arg3) {
20780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20781     return ;
20782   }
20783   {
20784     try {
20785       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20786     } catch (std::out_of_range& e) {
20787       {
20788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20789       };
20790     } catch (std::exception& e) {
20791       {
20792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20793       };
20794     } catch (Dali::DaliException e) {
20795       {
20796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20797       };
20798     } catch (...) {
20799       {
20800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20801       };
20802     }
20803   }
20804
20805 }
20806
20807
20808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20809   int jresult ;
20810   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20811   std::string *arg2 = 0 ;
20812   Dali::Property::Value *arg3 = 0 ;
20813   Dali::Property::Index result;
20814
20815   arg1 = (Dali::Handle *)jarg1;
20816   if (!jarg2) {
20817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20818     return 0;
20819   }
20820   std::string arg2_str(jarg2);
20821   arg2 = &arg2_str;
20822   arg3 = (Dali::Property::Value *)jarg3;
20823   if (!arg3) {
20824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20825     return 0;
20826   }
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20858   int jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   std::string *arg2 = 0 ;
20861   Dali::Property::Value *arg3 = 0 ;
20862   Dali::Property::AccessMode arg4 ;
20863   Dali::Property::Index result;
20864
20865   arg1 = (Dali::Handle *)jarg1;
20866   if (!jarg2) {
20867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20868     return 0;
20869   }
20870   std::string arg2_str(jarg2);
20871   arg2 = &arg2_str;
20872   arg3 = (Dali::Property::Value *)jarg3;
20873   if (!arg3) {
20874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20875     return 0;
20876   }
20877   arg4 = (Dali::Property::AccessMode)jarg4;
20878   {
20879     try {
20880       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20881     } catch (std::out_of_range& e) {
20882       {
20883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20884       };
20885     } catch (std::exception& e) {
20886       {
20887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20888       };
20889     } catch (Dali::DaliException e) {
20890       {
20891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20892       };
20893     } catch (...) {
20894       {
20895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20896       };
20897     }
20898   }
20899
20900   jresult = result;
20901
20902   //argout typemap for const std::string&
20903
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20909   void * jresult ;
20910   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20911   Dali::Property::Index arg2 ;
20912   Dali::Property::Value result;
20913
20914   arg1 = (Dali::Handle *)jarg1;
20915   arg2 = (Dali::Property::Index)jarg2;
20916   {
20917     try {
20918       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20919     } catch (std::out_of_range& e) {
20920       {
20921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20922       };
20923     } catch (std::exception& e) {
20924       {
20925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20926       };
20927     } catch (Dali::DaliException e) {
20928       {
20929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20930       };
20931     } catch (...) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20934       };
20935     }
20936   }
20937
20938   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20939   return jresult;
20940 }
20941
20942
20943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20944   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20945   Dali::Property::IndexContainer *arg2 = 0 ;
20946
20947   arg1 = (Dali::Handle *)jarg1;
20948   arg2 = (Dali::Property::IndexContainer *)jarg2;
20949   if (!arg2) {
20950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20951     return ;
20952   }
20953   {
20954     try {
20955       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20956     } catch (std::out_of_range& e) {
20957       {
20958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20959       };
20960     } catch (std::exception& e) {
20961       {
20962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20963       };
20964     } catch (Dali::DaliException e) {
20965       {
20966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20967       };
20968     } catch (...) {
20969       {
20970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20971       };
20972     }
20973   }
20974
20975 }
20976
20977
20978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20979   void * jresult ;
20980   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20981   Dali::Property::Index arg2 ;
20982   Dali::PropertyCondition *arg3 = 0 ;
20983   Dali::PropertyNotification result;
20984
20985   arg1 = (Dali::Handle *)jarg1;
20986   arg2 = (Dali::Property::Index)jarg2;
20987   arg3 = (Dali::PropertyCondition *)jarg3;
20988   if (!arg3) {
20989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20990     return 0;
20991   }
20992   {
20993     try {
20994       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20995     } catch (std::out_of_range& e) {
20996       {
20997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20998       };
20999     } catch (std::exception& e) {
21000       {
21001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21002       };
21003     } catch (Dali::DaliException e) {
21004       {
21005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21006       };
21007     } catch (...) {
21008       {
21009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21010       };
21011     }
21012   }
21013
21014   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21015   return jresult;
21016 }
21017
21018
21019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21020   void * jresult ;
21021   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21022   Dali::Property::Index arg2 ;
21023   int arg3 ;
21024   Dali::PropertyCondition *arg4 = 0 ;
21025   Dali::PropertyNotification result;
21026
21027   arg1 = (Dali::Handle *)jarg1;
21028   arg2 = (Dali::Property::Index)jarg2;
21029   arg3 = (int)jarg3;
21030   arg4 = (Dali::PropertyCondition *)jarg4;
21031   if (!arg4) {
21032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21033     return 0;
21034   }
21035   {
21036     try {
21037       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21038     } catch (std::out_of_range& e) {
21039       {
21040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21041       };
21042     } catch (std::exception& e) {
21043       {
21044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21045       };
21046     } catch (Dali::DaliException e) {
21047       {
21048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21049       };
21050     } catch (...) {
21051       {
21052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21053       };
21054     }
21055   }
21056
21057   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21058   return jresult;
21059 }
21060
21061
21062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21063   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21064   Dali::PropertyNotification arg2 ;
21065   Dali::PropertyNotification *argp2 ;
21066
21067   arg1 = (Dali::Handle *)jarg1;
21068   argp2 = (Dali::PropertyNotification *)jarg2;
21069   if (!argp2) {
21070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21071     return ;
21072   }
21073   arg2 = *argp2;
21074   {
21075     try {
21076       (arg1)->RemovePropertyNotification(arg2);
21077     } catch (std::out_of_range& e) {
21078       {
21079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21080       };
21081     } catch (std::exception& e) {
21082       {
21083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21084       };
21085     } catch (Dali::DaliException e) {
21086       {
21087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21088       };
21089     } catch (...) {
21090       {
21091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21092       };
21093     }
21094   }
21095
21096 }
21097
21098
21099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21100   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21101
21102   arg1 = (Dali::Handle *)jarg1;
21103   {
21104     try {
21105       (arg1)->RemovePropertyNotifications();
21106     } catch (std::out_of_range& e) {
21107       {
21108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21109       };
21110     } catch (std::exception& e) {
21111       {
21112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21113       };
21114     } catch (Dali::DaliException e) {
21115       {
21116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21117       };
21118     } catch (...) {
21119       {
21120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21121       };
21122     }
21123   }
21124
21125 }
21126
21127
21128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21129   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21130
21131   arg1 = (Dali::Handle *)jarg1;
21132   {
21133     try {
21134       (arg1)->RemoveConstraints();
21135     } catch (std::out_of_range& e) {
21136       {
21137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (std::exception& e) {
21140       {
21141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21142       };
21143     } catch (Dali::DaliException e) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21146       };
21147     } catch (...) {
21148       {
21149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21150       };
21151     }
21152   }
21153
21154 }
21155
21156
21157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21158   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21159   unsigned int arg2 ;
21160
21161   arg1 = (Dali::Handle *)jarg1;
21162   arg2 = (unsigned int)jarg2;
21163   {
21164     try {
21165       (arg1)->RemoveConstraints(arg2);
21166     } catch (std::out_of_range& e) {
21167       {
21168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21169       };
21170     } catch (std::exception& e) {
21171       {
21172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21173       };
21174     } catch (Dali::DaliException e) {
21175       {
21176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21177       };
21178     } catch (...) {
21179       {
21180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21181       };
21182     }
21183   }
21184
21185 }
21186
21187
21188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21189   int jresult ;
21190   Dali::Property::Index result;
21191
21192   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21193   jresult = result;
21194   return jresult;
21195 }
21196
21197
21198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21199   void * jresult ;
21200   Dali::Handle result;
21201
21202   {
21203     try {
21204       result = Dali::WeightObject::New();
21205     } catch (std::out_of_range& e) {
21206       {
21207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (std::exception& e) {
21210       {
21211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21212       };
21213     } catch (Dali::DaliException e) {
21214       {
21215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21216       };
21217     } catch (...) {
21218       {
21219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21220       };
21221     }
21222   }
21223
21224   jresult = new Dali::Handle((const Dali::Handle &)result);
21225   return jresult;
21226 }
21227
21228
21229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21230   void * jresult ;
21231   Dali::TypeInfo *result = 0 ;
21232
21233   {
21234     try {
21235       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21236     } catch (std::out_of_range& e) {
21237       {
21238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21239       };
21240     } catch (std::exception& e) {
21241       {
21242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21243       };
21244     } catch (Dali::DaliException e) {
21245       {
21246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21247       };
21248     } catch (...) {
21249       {
21250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21251       };
21252     }
21253   }
21254
21255   jresult = (void *)result;
21256   return jresult;
21257 }
21258
21259
21260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21261   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21262
21263   arg1 = (Dali::TypeInfo *)jarg1;
21264   {
21265     try {
21266       delete arg1;
21267     } catch (std::out_of_range& e) {
21268       {
21269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21270       };
21271     } catch (std::exception& e) {
21272       {
21273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21274       };
21275     } catch (Dali::DaliException e) {
21276       {
21277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21278       };
21279     } catch (...) {
21280       {
21281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21282       };
21283     }
21284   }
21285
21286 }
21287
21288
21289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21290   void * jresult ;
21291   Dali::TypeInfo *arg1 = 0 ;
21292   Dali::TypeInfo *result = 0 ;
21293
21294   arg1 = (Dali::TypeInfo *)jarg1;
21295   if (!arg1) {
21296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21297     return 0;
21298   }
21299   {
21300     try {
21301       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21302     } catch (std::out_of_range& e) {
21303       {
21304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21305       };
21306     } catch (std::exception& e) {
21307       {
21308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21309       };
21310     } catch (Dali::DaliException e) {
21311       {
21312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21313       };
21314     } catch (...) {
21315       {
21316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21317       };
21318     }
21319   }
21320
21321   jresult = (void *)result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21327   void * jresult ;
21328   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21329   Dali::TypeInfo *arg2 = 0 ;
21330   Dali::TypeInfo *result = 0 ;
21331
21332   arg1 = (Dali::TypeInfo *)jarg1;
21333   arg2 = (Dali::TypeInfo *)jarg2;
21334   if (!arg2) {
21335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21336     return 0;
21337   }
21338   {
21339     try {
21340       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21341     } catch (std::out_of_range& e) {
21342       {
21343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21344       };
21345     } catch (std::exception& e) {
21346       {
21347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21348       };
21349     } catch (Dali::DaliException e) {
21350       {
21351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21352       };
21353     } catch (...) {
21354       {
21355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21356       };
21357     }
21358   }
21359
21360   jresult = (void *)result;
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21366   char * jresult ;
21367   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21368   std::string *result = 0 ;
21369
21370   arg1 = (Dali::TypeInfo *)jarg1;
21371   {
21372     try {
21373       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21374     } catch (std::out_of_range& e) {
21375       {
21376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21377       };
21378     } catch (std::exception& e) {
21379       {
21380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21381       };
21382     } catch (Dali::DaliException e) {
21383       {
21384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21385       };
21386     } catch (...) {
21387       {
21388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21389       };
21390     }
21391   }
21392
21393   jresult = SWIG_csharp_string_callback(result->c_str());
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21399   char * jresult ;
21400   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21401   std::string *result = 0 ;
21402
21403   arg1 = (Dali::TypeInfo *)jarg1;
21404   {
21405     try {
21406       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21407     } catch (std::out_of_range& e) {
21408       {
21409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21410       };
21411     } catch (std::exception& e) {
21412       {
21413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21414       };
21415     } catch (Dali::DaliException e) {
21416       {
21417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21418       };
21419     } catch (...) {
21420       {
21421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21422       };
21423     }
21424   }
21425
21426   jresult = SWIG_csharp_string_callback(result->c_str());
21427   return jresult;
21428 }
21429
21430
21431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21432   void * jresult ;
21433   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21434   Dali::BaseHandle result;
21435
21436   arg1 = (Dali::TypeInfo *)jarg1;
21437   {
21438     try {
21439       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21440     } catch (std::out_of_range& e) {
21441       {
21442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21443       };
21444     } catch (std::exception& e) {
21445       {
21446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21447       };
21448     } catch (Dali::DaliException e) {
21449       {
21450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21451       };
21452     } catch (...) {
21453       {
21454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21455       };
21456     }
21457   }
21458
21459   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21460   return jresult;
21461 }
21462
21463
21464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21465   unsigned long jresult ;
21466   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21467   size_t result;
21468
21469   arg1 = (Dali::TypeInfo *)jarg1;
21470   {
21471     try {
21472       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21473     } catch (std::out_of_range& e) {
21474       {
21475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21476       };
21477     } catch (std::exception& e) {
21478       {
21479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (Dali::DaliException e) {
21482       {
21483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21484       };
21485     } catch (...) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21488       };
21489     }
21490   }
21491
21492   jresult = (unsigned long)result;
21493   return jresult;
21494 }
21495
21496
21497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21498   char * jresult ;
21499   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21500   size_t arg2 ;
21501   std::string result;
21502
21503   arg1 = (Dali::TypeInfo *)jarg1;
21504   arg2 = (size_t)jarg2;
21505   {
21506     try {
21507       result = (arg1)->GetActionName(arg2);
21508     } catch (std::out_of_range& e) {
21509       {
21510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21511       };
21512     } catch (std::exception& e) {
21513       {
21514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21515       };
21516     } catch (Dali::DaliException e) {
21517       {
21518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21519       };
21520     } catch (...) {
21521       {
21522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21523       };
21524     }
21525   }
21526
21527   jresult = SWIG_csharp_string_callback((&result)->c_str());
21528   return jresult;
21529 }
21530
21531
21532 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21533   unsigned long jresult ;
21534   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21535   size_t result;
21536
21537   arg1 = (Dali::TypeInfo *)jarg1;
21538   {
21539     try {
21540       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21541     } catch (std::out_of_range& e) {
21542       {
21543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21544       };
21545     } catch (std::exception& e) {
21546       {
21547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21548       };
21549     } catch (Dali::DaliException e) {
21550       {
21551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21552       };
21553     } catch (...) {
21554       {
21555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21556       };
21557     }
21558   }
21559
21560   jresult = (unsigned long)result;
21561   return jresult;
21562 }
21563
21564
21565 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21566   char * jresult ;
21567   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21568   size_t arg2 ;
21569   std::string result;
21570
21571   arg1 = (Dali::TypeInfo *)jarg1;
21572   arg2 = (size_t)jarg2;
21573   {
21574     try {
21575       result = (arg1)->GetSignalName(arg2);
21576     } catch (std::out_of_range& e) {
21577       {
21578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21579       };
21580     } catch (std::exception& e) {
21581       {
21582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21583       };
21584     } catch (Dali::DaliException e) {
21585       {
21586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21587       };
21588     } catch (...) {
21589       {
21590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21591       };
21592     }
21593   }
21594
21595   jresult = SWIG_csharp_string_callback((&result)->c_str());
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21601   unsigned long jresult ;
21602   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21603   size_t result;
21604
21605   arg1 = (Dali::TypeInfo *)jarg1;
21606   {
21607     try {
21608       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21609     } catch (std::out_of_range& e) {
21610       {
21611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21612       };
21613     } catch (std::exception& e) {
21614       {
21615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21616       };
21617     } catch (Dali::DaliException e) {
21618       {
21619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21620       };
21621     } catch (...) {
21622       {
21623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21624       };
21625     }
21626   }
21627
21628   jresult = (unsigned long)result;
21629   return jresult;
21630 }
21631
21632
21633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21634   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21635   Dali::Property::IndexContainer *arg2 = 0 ;
21636
21637   arg1 = (Dali::TypeInfo *)jarg1;
21638   arg2 = (Dali::Property::IndexContainer *)jarg2;
21639   if (!arg2) {
21640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21641     return ;
21642   }
21643   {
21644     try {
21645       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21646     } catch (std::out_of_range& e) {
21647       {
21648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21649       };
21650     } catch (std::exception& e) {
21651       {
21652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21653       };
21654     } catch (Dali::DaliException e) {
21655       {
21656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21657       };
21658     } catch (...) {
21659       {
21660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21661       };
21662     }
21663   }
21664
21665 }
21666
21667
21668 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21669   char * jresult ;
21670   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21671   Dali::Property::Index arg2 ;
21672   std::string *result = 0 ;
21673
21674   arg1 = (Dali::TypeInfo *)jarg1;
21675   arg2 = (Dali::Property::Index)jarg2;
21676   {
21677     try {
21678       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21679     } catch (std::out_of_range& e) {
21680       {
21681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21682       };
21683     } catch (std::exception& e) {
21684       {
21685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21686       };
21687     } catch (Dali::DaliException e) {
21688       {
21689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21690       };
21691     } catch (...) {
21692       {
21693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21694       };
21695     }
21696   }
21697
21698   jresult = SWIG_csharp_string_callback(result->c_str());
21699   return jresult;
21700 }
21701
21702
21703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21704   void * jresult ;
21705   Dali::TypeRegistry result;
21706
21707   {
21708     try {
21709       result = Dali::TypeRegistry::Get();
21710     } catch (std::out_of_range& e) {
21711       {
21712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (std::exception& e) {
21715       {
21716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21717       };
21718     } catch (Dali::DaliException e) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21721       };
21722     } catch (...) {
21723       {
21724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21725       };
21726     }
21727   }
21728
21729   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21730   return jresult;
21731 }
21732
21733
21734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21735   void * jresult ;
21736   Dali::TypeRegistry *result = 0 ;
21737
21738   {
21739     try {
21740       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21741     } catch (std::out_of_range& e) {
21742       {
21743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21744       };
21745     } catch (std::exception& e) {
21746       {
21747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21748       };
21749     } catch (Dali::DaliException e) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21756       };
21757     }
21758   }
21759
21760   jresult = (void *)result;
21761   return jresult;
21762 }
21763
21764
21765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21766   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21767
21768   arg1 = (Dali::TypeRegistry *)jarg1;
21769   {
21770     try {
21771       delete arg1;
21772     } catch (std::out_of_range& e) {
21773       {
21774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21775       };
21776     } catch (std::exception& e) {
21777       {
21778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21779       };
21780     } catch (Dali::DaliException e) {
21781       {
21782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21783       };
21784     } catch (...) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21787       };
21788     }
21789   }
21790
21791 }
21792
21793
21794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21795   void * jresult ;
21796   Dali::TypeRegistry *arg1 = 0 ;
21797   Dali::TypeRegistry *result = 0 ;
21798
21799   arg1 = (Dali::TypeRegistry *)jarg1;
21800   if (!arg1) {
21801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21802     return 0;
21803   }
21804   {
21805     try {
21806       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21807     } catch (std::out_of_range& e) {
21808       {
21809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (std::exception& e) {
21812       {
21813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21814       };
21815     } catch (Dali::DaliException e) {
21816       {
21817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21818       };
21819     } catch (...) {
21820       {
21821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21822       };
21823     }
21824   }
21825
21826   jresult = (void *)result;
21827   return jresult;
21828 }
21829
21830
21831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21832   void * jresult ;
21833   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21834   Dali::TypeRegistry *arg2 = 0 ;
21835   Dali::TypeRegistry *result = 0 ;
21836
21837   arg1 = (Dali::TypeRegistry *)jarg1;
21838   arg2 = (Dali::TypeRegistry *)jarg2;
21839   if (!arg2) {
21840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21841     return 0;
21842   }
21843   {
21844     try {
21845       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21846     } catch (std::out_of_range& e) {
21847       {
21848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21849       };
21850     } catch (std::exception& e) {
21851       {
21852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21853       };
21854     } catch (Dali::DaliException e) {
21855       {
21856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21857       };
21858     } catch (...) {
21859       {
21860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21861       };
21862     }
21863   }
21864
21865   jresult = (void *)result;
21866   return jresult;
21867 }
21868
21869
21870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21871   void * jresult ;
21872   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21873   std::string *arg2 = 0 ;
21874   Dali::TypeInfo result;
21875
21876   arg1 = (Dali::TypeRegistry *)jarg1;
21877   if (!jarg2) {
21878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21879     return 0;
21880   }
21881   std::string arg2_str(jarg2);
21882   arg2 = &arg2_str;
21883   {
21884     try {
21885       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21886     } catch (std::out_of_range& e) {
21887       {
21888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21889       };
21890     } catch (std::exception& e) {
21891       {
21892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21893       };
21894     } catch (Dali::DaliException e) {
21895       {
21896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21897       };
21898     } catch (...) {
21899       {
21900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21901       };
21902     }
21903   }
21904
21905   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21906
21907   //argout typemap for const std::string&
21908
21909   return jresult;
21910 }
21911
21912
21913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21914   void * jresult ;
21915   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21916   std::type_info *arg2 = 0 ;
21917   Dali::TypeInfo result;
21918
21919   arg1 = (Dali::TypeRegistry *)jarg1;
21920   arg2 = (std::type_info *)jarg2;
21921   if (!arg2) {
21922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21923     return 0;
21924   }
21925   {
21926     try {
21927       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21928     } catch (std::out_of_range& e) {
21929       {
21930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21931       };
21932     } catch (std::exception& e) {
21933       {
21934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21935       };
21936     } catch (Dali::DaliException e) {
21937       {
21938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21939       };
21940     } catch (...) {
21941       {
21942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21943       };
21944     }
21945   }
21946
21947   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21953   unsigned long jresult ;
21954   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21955   size_t result;
21956
21957   arg1 = (Dali::TypeRegistry *)jarg1;
21958   {
21959     try {
21960       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21961     } catch (std::out_of_range& e) {
21962       {
21963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21964       };
21965     } catch (std::exception& e) {
21966       {
21967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (Dali::DaliException e) {
21970       {
21971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21972       };
21973     } catch (...) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21976       };
21977     }
21978   }
21979
21980   jresult = (unsigned long)result;
21981   return jresult;
21982 }
21983
21984
21985 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21986   char * jresult ;
21987   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21988   size_t arg2 ;
21989   std::string result;
21990
21991   arg1 = (Dali::TypeRegistry *)jarg1;
21992   arg2 = (size_t)jarg2;
21993   {
21994     try {
21995       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21996     } catch (std::out_of_range& e) {
21997       {
21998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21999       };
22000     } catch (std::exception& e) {
22001       {
22002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22003       };
22004     } catch (Dali::DaliException e) {
22005       {
22006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22007       };
22008     } catch (...) {
22009       {
22010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22011       };
22012     }
22013   }
22014
22015   jresult = SWIG_csharp_string_callback((&result)->c_str());
22016   return jresult;
22017 }
22018
22019
22020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22021   void * jresult ;
22022   std::type_info *arg1 = 0 ;
22023   std::type_info *arg2 = 0 ;
22024   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22025   Dali::TypeRegistration *result = 0 ;
22026
22027   arg1 = (std::type_info *)jarg1;
22028   if (!arg1) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg2 = (std::type_info *)jarg2;
22033   if (!arg2) {
22034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22035     return 0;
22036   }
22037   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22038   {
22039     try {
22040       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22048       };
22049     } catch (Dali::DaliException e) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22052       };
22053     } catch (...) {
22054       {
22055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22056       };
22057     }
22058   }
22059
22060   jresult = (void *)result;
22061   return jresult;
22062 }
22063
22064
22065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22066   void * jresult ;
22067   std::type_info *arg1 = 0 ;
22068   std::type_info *arg2 = 0 ;
22069   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22070   bool arg4 ;
22071   Dali::TypeRegistration *result = 0 ;
22072
22073   arg1 = (std::type_info *)jarg1;
22074   if (!arg1) {
22075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22076     return 0;
22077   }
22078   arg2 = (std::type_info *)jarg2;
22079   if (!arg2) {
22080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22081     return 0;
22082   }
22083   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22084   arg4 = jarg4 ? true : false;
22085   {
22086     try {
22087       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22088     } catch (std::out_of_range& e) {
22089       {
22090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22091       };
22092     } catch (std::exception& e) {
22093       {
22094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22095       };
22096     } catch (Dali::DaliException e) {
22097       {
22098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22099       };
22100     } catch (...) {
22101       {
22102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22103       };
22104     }
22105   }
22106
22107   jresult = (void *)result;
22108   return jresult;
22109 }
22110
22111
22112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22113   void * jresult ;
22114   std::string *arg1 = 0 ;
22115   std::type_info *arg2 = 0 ;
22116   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22117   Dali::TypeRegistration *result = 0 ;
22118
22119   if (!jarg1) {
22120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22121     return 0;
22122   }
22123   std::string arg1_str(jarg1);
22124   arg1 = &arg1_str;
22125   arg2 = (std::type_info *)jarg2;
22126   if (!arg2) {
22127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22128     return 0;
22129   }
22130   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22131   {
22132     try {
22133       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22134     } catch (std::out_of_range& e) {
22135       {
22136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22137       };
22138     } catch (std::exception& e) {
22139       {
22140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22141       };
22142     } catch (Dali::DaliException e) {
22143       {
22144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22145       };
22146     } catch (...) {
22147       {
22148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22149       };
22150     }
22151   }
22152
22153   jresult = (void *)result;
22154
22155   //argout typemap for const std::string&
22156
22157   return jresult;
22158 }
22159
22160
22161 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22162   char * jresult ;
22163   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22164   std::string result;
22165
22166   arg1 = (Dali::TypeRegistration *)jarg1;
22167   {
22168     try {
22169       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22170     } catch (std::out_of_range& e) {
22171       {
22172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22173       };
22174     } catch (std::exception& e) {
22175       {
22176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22177       };
22178     } catch (Dali::DaliException e) {
22179       {
22180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22181       };
22182     } catch (...) {
22183       {
22184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22185       };
22186     }
22187   }
22188
22189   jresult = SWIG_csharp_string_callback((&result)->c_str());
22190   return jresult;
22191 }
22192
22193
22194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22195   std::string *arg1 = 0 ;
22196   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22197
22198   if (!jarg1) {
22199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22200     return ;
22201   }
22202   std::string arg1_str(jarg1);
22203   arg1 = &arg1_str;
22204   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22205   {
22206     try {
22207       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22208     } catch (std::out_of_range& e) {
22209       {
22210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22211       };
22212     } catch (std::exception& e) {
22213       {
22214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22215       };
22216     } catch (Dali::DaliException e) {
22217       {
22218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22219       };
22220     } catch (...) {
22221       {
22222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22223       };
22224     }
22225   }
22226
22227
22228   //argout typemap for const std::string&
22229
22230 }
22231
22232
22233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22234   std::string *arg1 = 0 ;
22235   std::string *arg2 = 0 ;
22236   int arg3 ;
22237   Dali::Property::Type arg4 ;
22238   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22239   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22240
22241   if (!jarg1) {
22242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22243     return ;
22244   }
22245   std::string arg1_str(jarg1);
22246   arg1 = &arg1_str;
22247   if (!jarg2) {
22248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22249     return ;
22250   }
22251   std::string arg2_str(jarg2);
22252   arg2 = &arg2_str;
22253   arg3 = (int)jarg3;
22254   arg4 = (Dali::Property::Type)jarg4;
22255   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22256   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22257   {
22258     try {
22259       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22260     } catch (std::out_of_range& e) {
22261       {
22262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22263       };
22264     } catch (std::exception& e) {
22265       {
22266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (Dali::DaliException e) {
22269       {
22270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22275       };
22276     }
22277   }
22278
22279
22280   //argout typemap for const std::string&
22281
22282
22283   //argout typemap for const std::string&
22284
22285 }
22286
22287
22288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22289   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22290
22291   arg1 = (Dali::TypeRegistration *)jarg1;
22292   {
22293     try {
22294       delete arg1;
22295     } catch (std::out_of_range& e) {
22296       {
22297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22298       };
22299     } catch (std::exception& e) {
22300       {
22301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22302       };
22303     } catch (Dali::DaliException e) {
22304       {
22305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22306       };
22307     } catch (...) {
22308       {
22309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22310       };
22311     }
22312   }
22313
22314 }
22315
22316
22317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22318   void * jresult ;
22319   Dali::TypeRegistration *arg1 = 0 ;
22320   std::string *arg2 = 0 ;
22321   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22322   Dali::SignalConnectorType *result = 0 ;
22323
22324   arg1 = (Dali::TypeRegistration *)jarg1;
22325   if (!arg1) {
22326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22327     return 0;
22328   }
22329   if (!jarg2) {
22330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22331     return 0;
22332   }
22333   std::string arg2_str(jarg2);
22334   arg2 = &arg2_str;
22335   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22336   {
22337     try {
22338       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22339     } catch (std::out_of_range& e) {
22340       {
22341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22342       };
22343     } catch (std::exception& e) {
22344       {
22345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22346       };
22347     } catch (Dali::DaliException e) {
22348       {
22349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22350       };
22351     } catch (...) {
22352       {
22353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22354       };
22355     }
22356   }
22357
22358   jresult = (void *)result;
22359
22360   //argout typemap for const std::string&
22361
22362   return jresult;
22363 }
22364
22365
22366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22367   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22368
22369   arg1 = (Dali::SignalConnectorType *)jarg1;
22370   {
22371     try {
22372       delete arg1;
22373     } catch (std::out_of_range& e) {
22374       {
22375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22376       };
22377     } catch (std::exception& e) {
22378       {
22379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22380       };
22381     } catch (Dali::DaliException e) {
22382       {
22383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22384       };
22385     } catch (...) {
22386       {
22387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22388       };
22389     }
22390   }
22391
22392 }
22393
22394
22395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22396   void * jresult ;
22397   Dali::TypeRegistration *arg1 = 0 ;
22398   std::string *arg2 = 0 ;
22399   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22400   Dali::TypeAction *result = 0 ;
22401
22402   arg1 = (Dali::TypeRegistration *)jarg1;
22403   if (!arg1) {
22404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22405     return 0;
22406   }
22407   if (!jarg2) {
22408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22409     return 0;
22410   }
22411   std::string arg2_str(jarg2);
22412   arg2 = &arg2_str;
22413   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22414   {
22415     try {
22416       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22417     } catch (std::out_of_range& e) {
22418       {
22419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22420       };
22421     } catch (std::exception& e) {
22422       {
22423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22424       };
22425     } catch (Dali::DaliException e) {
22426       {
22427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22428       };
22429     } catch (...) {
22430       {
22431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22432       };
22433     }
22434   }
22435
22436   jresult = (void *)result;
22437
22438   //argout typemap for const std::string&
22439
22440   return jresult;
22441 }
22442
22443
22444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22445   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22446
22447   arg1 = (Dali::TypeAction *)jarg1;
22448   {
22449     try {
22450       delete arg1;
22451     } catch (std::out_of_range& e) {
22452       {
22453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22454       };
22455     } catch (std::exception& e) {
22456       {
22457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22458       };
22459     } catch (Dali::DaliException e) {
22460       {
22461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22462       };
22463     } catch (...) {
22464       {
22465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22466       };
22467     }
22468   }
22469
22470 }
22471
22472
22473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22474   void * jresult ;
22475   Dali::TypeRegistration *arg1 = 0 ;
22476   std::string *arg2 = 0 ;
22477   Dali::Property::Index arg3 ;
22478   Dali::Property::Type arg4 ;
22479   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22480   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22481   Dali::PropertyRegistration *result = 0 ;
22482
22483   arg1 = (Dali::TypeRegistration *)jarg1;
22484   if (!arg1) {
22485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22486     return 0;
22487   }
22488   if (!jarg2) {
22489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22490     return 0;
22491   }
22492   std::string arg2_str(jarg2);
22493   arg2 = &arg2_str;
22494   arg3 = (Dali::Property::Index)jarg3;
22495   arg4 = (Dali::Property::Type)jarg4;
22496   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22497   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22498   {
22499     try {
22500       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22501     } catch (std::out_of_range& e) {
22502       {
22503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22504       };
22505     } catch (std::exception& e) {
22506       {
22507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22508       };
22509     } catch (Dali::DaliException e) {
22510       {
22511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22512       };
22513     } catch (...) {
22514       {
22515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22516       };
22517     }
22518   }
22519
22520   jresult = (void *)result;
22521
22522   //argout typemap for const std::string&
22523
22524   return jresult;
22525 }
22526
22527
22528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22529   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22530
22531   arg1 = (Dali::PropertyRegistration *)jarg1;
22532   {
22533     try {
22534       delete arg1;
22535     } catch (std::out_of_range& e) {
22536       {
22537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22538       };
22539     } catch (std::exception& e) {
22540       {
22541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22542       };
22543     } catch (Dali::DaliException e) {
22544       {
22545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22546       };
22547     } catch (...) {
22548       {
22549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22550       };
22551     }
22552   }
22553
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Type arg4 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Type)jarg4;
22578   {
22579     try {
22580       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22581     } catch (std::out_of_range& e) {
22582       {
22583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22584       };
22585     } catch (std::exception& e) {
22586       {
22587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (Dali::DaliException e) {
22590       {
22591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22592       };
22593     } catch (...) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22596       };
22597     }
22598   }
22599
22600   jresult = (void *)result;
22601
22602   //argout typemap for const std::string&
22603
22604   return jresult;
22605 }
22606
22607
22608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22609   void * jresult ;
22610   Dali::TypeRegistration *arg1 = 0 ;
22611   std::string *arg2 = 0 ;
22612   Dali::Property::Index arg3 ;
22613   Dali::Property::Value *arg4 = 0 ;
22614   Dali::AnimatablePropertyRegistration *result = 0 ;
22615
22616   arg1 = (Dali::TypeRegistration *)jarg1;
22617   if (!arg1) {
22618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22619     return 0;
22620   }
22621   if (!jarg2) {
22622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22623     return 0;
22624   }
22625   std::string arg2_str(jarg2);
22626   arg2 = &arg2_str;
22627   arg3 = (Dali::Property::Index)jarg3;
22628   arg4 = (Dali::Property::Value *)jarg4;
22629   if (!arg4) {
22630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22631     return 0;
22632   }
22633   {
22634     try {
22635       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22636     } catch (std::out_of_range& e) {
22637       {
22638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22639       };
22640     } catch (std::exception& e) {
22641       {
22642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22643       };
22644     } catch (Dali::DaliException e) {
22645       {
22646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22647       };
22648     } catch (...) {
22649       {
22650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22651       };
22652     }
22653   }
22654
22655   jresult = (void *)result;
22656
22657   //argout typemap for const std::string&
22658
22659   return jresult;
22660 }
22661
22662
22663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22664   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22665
22666   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22667   {
22668     try {
22669       delete arg1;
22670     } catch (std::out_of_range& e) {
22671       {
22672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22673       };
22674     } catch (std::exception& e) {
22675       {
22676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22677       };
22678     } catch (Dali::DaliException e) {
22679       {
22680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22681       };
22682     } catch (...) {
22683       {
22684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22685       };
22686     }
22687   }
22688
22689 }
22690
22691
22692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22693   void * jresult ;
22694   Dali::TypeRegistration *arg1 = 0 ;
22695   std::string *arg2 = 0 ;
22696   Dali::Property::Index arg3 ;
22697   Dali::Property::Index arg4 ;
22698   unsigned int arg5 ;
22699   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22700
22701   arg1 = (Dali::TypeRegistration *)jarg1;
22702   if (!arg1) {
22703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22704     return 0;
22705   }
22706   if (!jarg2) {
22707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22708     return 0;
22709   }
22710   std::string arg2_str(jarg2);
22711   arg2 = &arg2_str;
22712   arg3 = (Dali::Property::Index)jarg3;
22713   arg4 = (Dali::Property::Index)jarg4;
22714   arg5 = (unsigned int)jarg5;
22715   {
22716     try {
22717       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22718     } catch (std::out_of_range& e) {
22719       {
22720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22721       };
22722     } catch (std::exception& e) {
22723       {
22724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22725       };
22726     } catch (Dali::DaliException e) {
22727       {
22728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22729       };
22730     } catch (...) {
22731       {
22732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22733       };
22734     }
22735   }
22736
22737   jresult = (void *)result;
22738
22739   //argout typemap for const std::string&
22740
22741   return jresult;
22742 }
22743
22744
22745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22746   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22747
22748   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22749   {
22750     try {
22751       delete arg1;
22752     } catch (std::out_of_range& e) {
22753       {
22754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22755       };
22756     } catch (std::exception& e) {
22757       {
22758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22759       };
22760     } catch (Dali::DaliException e) {
22761       {
22762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22763       };
22764     } catch (...) {
22765       {
22766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22767       };
22768     }
22769   }
22770
22771 }
22772
22773
22774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22775   void * jresult ;
22776   Dali::TypeRegistration *arg1 = 0 ;
22777   std::string *arg2 = 0 ;
22778   Dali::Property::Index arg3 ;
22779   Dali::Property::Type arg4 ;
22780   Dali::ChildPropertyRegistration *result = 0 ;
22781
22782   arg1 = (Dali::TypeRegistration *)jarg1;
22783   if (!arg1) {
22784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22785     return 0;
22786   }
22787   if (!jarg2) {
22788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22789     return 0;
22790   }
22791   std::string arg2_str(jarg2);
22792   arg2 = &arg2_str;
22793   arg3 = (Dali::Property::Index)jarg3;
22794   arg4 = (Dali::Property::Type)jarg4;
22795   {
22796     try {
22797       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22798     } catch (std::out_of_range& e) {
22799       {
22800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22801       };
22802     } catch (std::exception& e) {
22803       {
22804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22805       };
22806     } catch (Dali::DaliException e) {
22807       {
22808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22809       };
22810     } catch (...) {
22811       {
22812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22813       };
22814     }
22815   }
22816
22817   jresult = (void *)result;
22818
22819   //argout typemap for const std::string&
22820
22821   return jresult;
22822 }
22823
22824
22825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22826   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22827
22828   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22829   {
22830     try {
22831       delete arg1;
22832     } catch (std::out_of_range& e) {
22833       {
22834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22835       };
22836     } catch (std::exception& e) {
22837       {
22838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22839       };
22840     } catch (Dali::DaliException e) {
22841       {
22842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22843       };
22844     } catch (...) {
22845       {
22846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22847       };
22848     }
22849   }
22850
22851 }
22852
22853
22854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22855   unsigned int jresult ;
22856   std::string *arg1 = 0 ;
22857   std::type_info *arg2 = 0 ;
22858   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22859   bool result;
22860
22861   if (!jarg1) {
22862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22863     return 0;
22864   }
22865   std::string arg1_str(jarg1);
22866   arg1 = &arg1_str;
22867   arg2 = (std::type_info *)jarg2;
22868   if (!arg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22870     return 0;
22871   }
22872   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22873   {
22874     try {
22875       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22876     } catch (std::out_of_range& e) {
22877       {
22878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22879       };
22880     } catch (std::exception& e) {
22881       {
22882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22883       };
22884     } catch (Dali::DaliException e) {
22885       {
22886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22887       };
22888     } catch (...) {
22889       {
22890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22891       };
22892     }
22893   }
22894
22895   jresult = result;
22896
22897   //argout typemap for const std::string&
22898
22899   return jresult;
22900 }
22901
22902
22903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22904   unsigned int jresult ;
22905   std::string *arg1 = 0 ;
22906   std::string *arg2 = 0 ;
22907   Dali::Property::Index arg3 ;
22908   Dali::Property::Type arg4 ;
22909   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22910   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22911   bool result;
22912
22913   if (!jarg1) {
22914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22915     return 0;
22916   }
22917   std::string arg1_str(jarg1);
22918   arg1 = &arg1_str;
22919   if (!jarg2) {
22920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22921     return 0;
22922   }
22923   std::string arg2_str(jarg2);
22924   arg2 = &arg2_str;
22925   arg3 = (Dali::Property::Index)jarg3;
22926   arg4 = (Dali::Property::Type)jarg4;
22927   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22928   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22929   {
22930     try {
22931       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22932     } catch (std::out_of_range& e) {
22933       {
22934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22935       };
22936     } catch (std::exception& e) {
22937       {
22938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22939       };
22940     } catch (Dali::DaliException e) {
22941       {
22942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22943       };
22944     } catch (...) {
22945       {
22946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22947       };
22948     }
22949   }
22950
22951   jresult = result;
22952
22953   //argout typemap for const std::string&
22954
22955
22956   //argout typemap for const std::string&
22957
22958   return jresult;
22959 }
22960
22961
22962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22963   float jresult ;
22964   float result;
22965
22966   result = (float)(float)Dali::ParentOrigin::TOP;
22967   jresult = result;
22968   return jresult;
22969 }
22970
22971
22972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22973   float jresult ;
22974   float result;
22975
22976   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22977   jresult = result;
22978   return jresult;
22979 }
22980
22981
22982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22983   float jresult ;
22984   float result;
22985
22986   result = (float)(float)Dali::ParentOrigin::LEFT;
22987   jresult = result;
22988   return jresult;
22989 }
22990
22991
22992 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22993   float jresult ;
22994   float result;
22995
22996   result = (float)(float)Dali::ParentOrigin::RIGHT;
22997   jresult = result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23003   float jresult ;
23004   float result;
23005
23006   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23007   jresult = result;
23008   return jresult;
23009 }
23010
23011
23012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23013   void * jresult ;
23014   Dali::Vector3 *result = 0 ;
23015
23016   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23017   jresult = (void *)result;
23018   return jresult;
23019 }
23020
23021
23022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23023   void * jresult ;
23024   Dali::Vector3 *result = 0 ;
23025
23026   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23027   jresult = (void *)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23033   void * jresult ;
23034   Dali::Vector3 *result = 0 ;
23035
23036   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23037   jresult = (void *)result;
23038   return jresult;
23039 }
23040
23041
23042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23043   void * jresult ;
23044   Dali::Vector3 *result = 0 ;
23045
23046   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23047   jresult = (void *)result;
23048   return jresult;
23049 }
23050
23051
23052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23053   void * jresult ;
23054   Dali::Vector3 *result = 0 ;
23055
23056   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23057   jresult = (void *)result;
23058   return jresult;
23059 }
23060
23061
23062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23063   void * jresult ;
23064   Dali::Vector3 *result = 0 ;
23065
23066   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23067   jresult = (void *)result;
23068   return jresult;
23069 }
23070
23071
23072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23073   void * jresult ;
23074   Dali::Vector3 *result = 0 ;
23075
23076   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23077   jresult = (void *)result;
23078   return jresult;
23079 }
23080
23081
23082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23083   void * jresult ;
23084   Dali::Vector3 *result = 0 ;
23085
23086   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23087   jresult = (void *)result;
23088   return jresult;
23089 }
23090
23091
23092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23093   void * jresult ;
23094   Dali::Vector3 *result = 0 ;
23095
23096   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23097   jresult = (void *)result;
23098   return jresult;
23099 }
23100
23101
23102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23103   float jresult ;
23104   float result;
23105
23106   result = (float)(float)Dali::AnchorPoint::TOP;
23107   jresult = result;
23108   return jresult;
23109 }
23110
23111
23112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23113   float jresult ;
23114   float result;
23115
23116   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23117   jresult = result;
23118   return jresult;
23119 }
23120
23121
23122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23123   float jresult ;
23124   float result;
23125
23126   result = (float)(float)Dali::AnchorPoint::LEFT;
23127   jresult = result;
23128   return jresult;
23129 }
23130
23131
23132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23133   float jresult ;
23134   float result;
23135
23136   result = (float)(float)Dali::AnchorPoint::RIGHT;
23137   jresult = result;
23138   return jresult;
23139 }
23140
23141
23142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23143   float jresult ;
23144   float result;
23145
23146   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23147   jresult = result;
23148   return jresult;
23149 }
23150
23151
23152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23153   void * jresult ;
23154   Dali::Vector3 *result = 0 ;
23155
23156   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23157   jresult = (void *)result;
23158   return jresult;
23159 }
23160
23161
23162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23163   void * jresult ;
23164   Dali::Vector3 *result = 0 ;
23165
23166   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23167   jresult = (void *)result;
23168   return jresult;
23169 }
23170
23171
23172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23173   void * jresult ;
23174   Dali::Vector3 *result = 0 ;
23175
23176   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23177   jresult = (void *)result;
23178   return jresult;
23179 }
23180
23181
23182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23183   void * jresult ;
23184   Dali::Vector3 *result = 0 ;
23185
23186   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23187   jresult = (void *)result;
23188   return jresult;
23189 }
23190
23191
23192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23193   void * jresult ;
23194   Dali::Vector3 *result = 0 ;
23195
23196   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23197   jresult = (void *)result;
23198   return jresult;
23199 }
23200
23201
23202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23203   void * jresult ;
23204   Dali::Vector3 *result = 0 ;
23205
23206   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23207   jresult = (void *)result;
23208   return jresult;
23209 }
23210
23211
23212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23213   void * jresult ;
23214   Dali::Vector3 *result = 0 ;
23215
23216   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23217   jresult = (void *)result;
23218   return jresult;
23219 }
23220
23221
23222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23223   void * jresult ;
23224   Dali::Vector3 *result = 0 ;
23225
23226   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23227   jresult = (void *)result;
23228   return jresult;
23229 }
23230
23231
23232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23233   void * jresult ;
23234   Dali::Vector3 *result = 0 ;
23235
23236   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23237   jresult = (void *)result;
23238   return jresult;
23239 }
23240
23241
23242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23243   void * jresult ;
23244   Dali::Vector4 *result = 0 ;
23245
23246   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23247   jresult = (void *)result;
23248   return jresult;
23249 }
23250
23251
23252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23253   void * jresult ;
23254   Dali::Vector4 *result = 0 ;
23255
23256   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23257   jresult = (void *)result;
23258   return jresult;
23259 }
23260
23261
23262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23263   void * jresult ;
23264   Dali::Vector4 *result = 0 ;
23265
23266   result = (Dali::Vector4 *)&Dali::Color::RED;
23267   jresult = (void *)result;
23268   return jresult;
23269 }
23270
23271
23272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23273   void * jresult ;
23274   Dali::Vector4 *result = 0 ;
23275
23276   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23277   jresult = (void *)result;
23278   return jresult;
23279 }
23280
23281
23282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23283   void * jresult ;
23284   Dali::Vector4 *result = 0 ;
23285
23286   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23287   jresult = (void *)result;
23288   return jresult;
23289 }
23290
23291
23292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23293   void * jresult ;
23294   Dali::Vector4 *result = 0 ;
23295
23296   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23297   jresult = (void *)result;
23298   return jresult;
23299 }
23300
23301
23302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23303   void * jresult ;
23304   Dali::Vector4 *result = 0 ;
23305
23306   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23307   jresult = (void *)result;
23308   return jresult;
23309 }
23310
23311
23312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23313   void * jresult ;
23314   Dali::Vector4 *result = 0 ;
23315
23316   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23317   jresult = (void *)result;
23318   return jresult;
23319 }
23320
23321
23322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23323   void * jresult ;
23324   Dali::Vector4 *result = 0 ;
23325
23326   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23327   jresult = (void *)result;
23328   return jresult;
23329 }
23330
23331
23332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23333   float jresult ;
23334   float result;
23335
23336   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23337   jresult = result;
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23343   float jresult ;
23344   float result;
23345
23346   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23347   jresult = result;
23348   return jresult;
23349 }
23350
23351
23352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23353   float jresult ;
23354   float result;
23355
23356   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23357   jresult = result;
23358   return jresult;
23359 }
23360
23361
23362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23363   float jresult ;
23364   float result;
23365
23366   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23367   jresult = result;
23368   return jresult;
23369 }
23370
23371
23372 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23373   float jresult ;
23374   float result;
23375
23376   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23377   jresult = result;
23378   return jresult;
23379 }
23380
23381
23382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23383   float jresult ;
23384   float result;
23385
23386   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23387   jresult = result;
23388   return jresult;
23389 }
23390
23391
23392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23393   float jresult ;
23394   float result;
23395
23396   result = (float)(float)Dali::Math::PI;
23397   jresult = result;
23398   return jresult;
23399 }
23400
23401
23402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23403   float jresult ;
23404   float result;
23405
23406   result = (float)(float)Dali::Math::PI_2;
23407   jresult = result;
23408   return jresult;
23409 }
23410
23411
23412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23413   float jresult ;
23414   float result;
23415
23416   result = (float)(float)Dali::Math::PI_4;
23417   jresult = result;
23418   return jresult;
23419 }
23420
23421
23422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23423   float jresult ;
23424   float result;
23425
23426   result = (float)(float)Dali::Math::PI_OVER_180;
23427   jresult = result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23433   float jresult ;
23434   float result;
23435
23436   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23437   jresult = result;
23438   return jresult;
23439 }
23440
23441
23442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23443   int jresult ;
23444   Dali::ResizePolicy::Type result;
23445
23446   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23447   jresult = (int)result;
23448   return jresult;
23449 }
23450
23451
23452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23453   unsigned long jresult ;
23454   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23455   Dali::VectorBase::SizeType result;
23456
23457   arg1 = (Dali::VectorBase *)jarg1;
23458   {
23459     try {
23460       result = ((Dali::VectorBase const *)arg1)->Count();
23461     } catch (std::out_of_range& e) {
23462       {
23463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23464       };
23465     } catch (std::exception& e) {
23466       {
23467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23468       };
23469     } catch (Dali::DaliException e) {
23470       {
23471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23472       };
23473     } catch (...) {
23474       {
23475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23476       };
23477     }
23478   }
23479
23480   jresult = (unsigned long)result;
23481   return jresult;
23482 }
23483
23484
23485 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23486   unsigned long jresult ;
23487   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23488   Dali::VectorBase::SizeType result;
23489
23490   arg1 = (Dali::VectorBase *)jarg1;
23491   {
23492     try {
23493       result = ((Dali::VectorBase const *)arg1)->Size();
23494     } catch (std::out_of_range& e) {
23495       {
23496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23497       };
23498     } catch (std::exception& e) {
23499       {
23500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23501       };
23502     } catch (Dali::DaliException e) {
23503       {
23504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23505       };
23506     } catch (...) {
23507       {
23508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23509       };
23510     }
23511   }
23512
23513   jresult = (unsigned long)result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23519   unsigned int jresult ;
23520   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23521   bool result;
23522
23523   arg1 = (Dali::VectorBase *)jarg1;
23524   {
23525     try {
23526       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23527     } catch (std::out_of_range& e) {
23528       {
23529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23530       };
23531     } catch (std::exception& e) {
23532       {
23533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23534       };
23535     } catch (Dali::DaliException e) {
23536       {
23537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23538       };
23539     } catch (...) {
23540       {
23541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23542       };
23543     }
23544   }
23545
23546   jresult = result;
23547   return jresult;
23548 }
23549
23550
23551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23552   unsigned long jresult ;
23553   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23554   Dali::VectorBase::SizeType result;
23555
23556   arg1 = (Dali::VectorBase *)jarg1;
23557   {
23558     try {
23559       result = ((Dali::VectorBase const *)arg1)->Capacity();
23560     } catch (std::out_of_range& e) {
23561       {
23562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23563       };
23564     } catch (std::exception& e) {
23565       {
23566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23567       };
23568     } catch (Dali::DaliException e) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23571       };
23572     } catch (...) {
23573       {
23574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23575       };
23576     }
23577   }
23578
23579   jresult = (unsigned long)result;
23580   return jresult;
23581 }
23582
23583
23584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23585   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23586
23587   arg1 = (Dali::VectorBase *)jarg1;
23588   {
23589     try {
23590       (arg1)->Release();
23591     } catch (std::out_of_range& e) {
23592       {
23593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23594       };
23595     } catch (std::exception& e) {
23596       {
23597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23598       };
23599     } catch (Dali::DaliException e) {
23600       {
23601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23602       };
23603     } catch (...) {
23604       {
23605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23606       };
23607     }
23608   }
23609
23610 }
23611
23612
23613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23614   int jresult ;
23615   Dali::Pixel::Format result;
23616
23617   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23618   jresult = (int)result;
23619   return jresult;
23620 }
23621
23622
23623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23624   int jresult ;
23625   Dali::Pixel::Format result;
23626
23627   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23628   jresult = (int)result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23634   unsigned int jresult ;
23635   Dali::Pixel::Format arg1 ;
23636   bool result;
23637
23638   arg1 = (Dali::Pixel::Format)jarg1;
23639   {
23640     try {
23641       result = (bool)Dali::Pixel::HasAlpha(arg1);
23642     } catch (std::out_of_range& e) {
23643       {
23644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23645       };
23646     } catch (std::exception& e) {
23647       {
23648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23649       };
23650     } catch (Dali::DaliException e) {
23651       {
23652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23653       };
23654     } catch (...) {
23655       {
23656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23657       };
23658     }
23659   }
23660
23661   jresult = result;
23662   return jresult;
23663 }
23664
23665
23666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23667   unsigned int jresult ;
23668   Dali::Pixel::Format arg1 ;
23669   unsigned int result;
23670
23671   arg1 = (Dali::Pixel::Format)jarg1;
23672   {
23673     try {
23674       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23675     } catch (std::out_of_range& e) {
23676       {
23677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23678       };
23679     } catch (std::exception& e) {
23680       {
23681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23682       };
23683     } catch (Dali::DaliException e) {
23684       {
23685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23686       };
23687     } catch (...) {
23688       {
23689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23690       };
23691     }
23692   }
23693
23694   jresult = result;
23695   return jresult;
23696 }
23697
23698
23699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23700   Dali::Pixel::Format arg1 ;
23701   int *arg2 = 0 ;
23702   int *arg3 = 0 ;
23703
23704   arg1 = (Dali::Pixel::Format)jarg1;
23705   arg2 = (int *)jarg2;
23706   if (!arg2) {
23707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23708     return ;
23709   }
23710   arg3 = (int *)jarg3;
23711   if (!arg3) {
23712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23713     return ;
23714   }
23715   {
23716     try {
23717       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23718     } catch (std::out_of_range& e) {
23719       {
23720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23721       };
23722     } catch (std::exception& e) {
23723       {
23724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23725       };
23726     } catch (Dali::DaliException e) {
23727       {
23728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23729       };
23730     } catch (...) {
23731       {
23732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23733       };
23734     }
23735   }
23736
23737 }
23738
23739
23740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23741   void * jresult ;
23742   unsigned char *arg1 = (unsigned char *) 0 ;
23743   unsigned int arg2 ;
23744   unsigned int arg3 ;
23745   unsigned int arg4 ;
23746   Dali::Pixel::Format arg5 ;
23747   Dali::PixelData::ReleaseFunction arg6 ;
23748   Dali::PixelData result;
23749
23750   arg1 = jarg1;
23751   arg2 = (unsigned int)jarg2;
23752   arg3 = (unsigned int)jarg3;
23753   arg4 = (unsigned int)jarg4;
23754   arg5 = (Dali::Pixel::Format)jarg5;
23755   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23756   {
23757     try {
23758       auto pixelBuffer = new unsigned char[jarg2];
23759       memcpy( pixelBuffer, arg1, arg2);
23760       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23761     } catch (std::out_of_range& e) {
23762       {
23763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23764       };
23765     } catch (std::exception& e) {
23766       {
23767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23768       };
23769     } catch (Dali::DaliException e) {
23770       {
23771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23772       };
23773     } catch (...) {
23774       {
23775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23776       };
23777     }
23778   }
23779
23780   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23781
23782
23783   return jresult;
23784 }
23785
23786
23787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23788   void * jresult ;
23789   Dali::PixelData *result = 0 ;
23790
23791   {
23792     try {
23793       result = (Dali::PixelData *)new Dali::PixelData();
23794     } catch (std::out_of_range& e) {
23795       {
23796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23797       };
23798     } catch (std::exception& e) {
23799       {
23800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23801       };
23802     } catch (Dali::DaliException e) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23805       };
23806     } catch (...) {
23807       {
23808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23809       };
23810     }
23811   }
23812
23813   jresult = (void *)result;
23814   return jresult;
23815 }
23816
23817
23818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23819   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23820
23821   arg1 = (Dali::PixelData *)jarg1;
23822   {
23823     try {
23824       delete arg1;
23825     } catch (std::out_of_range& e) {
23826       {
23827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23828       };
23829     } catch (std::exception& e) {
23830       {
23831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23832       };
23833     } catch (Dali::DaliException e) {
23834       {
23835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23836       };
23837     } catch (...) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23840       };
23841     }
23842   }
23843
23844 }
23845
23846
23847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23848   void * jresult ;
23849   Dali::PixelData *arg1 = 0 ;
23850   Dali::PixelData *result = 0 ;
23851
23852   arg1 = (Dali::PixelData *)jarg1;
23853   if (!arg1) {
23854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23855     return 0;
23856   }
23857   {
23858     try {
23859       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23860     } catch (std::out_of_range& e) {
23861       {
23862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23863       };
23864     } catch (std::exception& e) {
23865       {
23866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (Dali::DaliException e) {
23869       {
23870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23871       };
23872     } catch (...) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23875       };
23876     }
23877   }
23878
23879   jresult = (void *)result;
23880   return jresult;
23881 }
23882
23883
23884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23885   void * jresult ;
23886   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23887   Dali::PixelData *arg2 = 0 ;
23888   Dali::PixelData *result = 0 ;
23889
23890   arg1 = (Dali::PixelData *)jarg1;
23891   arg2 = (Dali::PixelData *)jarg2;
23892   if (!arg2) {
23893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23894     return 0;
23895   }
23896   {
23897     try {
23898       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23899     } catch (std::out_of_range& e) {
23900       {
23901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23902       };
23903     } catch (std::exception& e) {
23904       {
23905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23906       };
23907     } catch (Dali::DaliException e) {
23908       {
23909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23910       };
23911     } catch (...) {
23912       {
23913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23914       };
23915     }
23916   }
23917
23918   jresult = (void *)result;
23919   return jresult;
23920 }
23921
23922
23923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23924   unsigned int jresult ;
23925   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23926   unsigned int result;
23927
23928   arg1 = (Dali::PixelData *)jarg1;
23929   {
23930     try {
23931       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23932     } catch (std::out_of_range& e) {
23933       {
23934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23935       };
23936     } catch (std::exception& e) {
23937       {
23938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23939       };
23940     } catch (Dali::DaliException e) {
23941       {
23942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23943       };
23944     } catch (...) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23947       };
23948     }
23949   }
23950
23951   jresult = result;
23952   return jresult;
23953 }
23954
23955
23956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23957   unsigned int jresult ;
23958   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23959   unsigned int result;
23960
23961   arg1 = (Dali::PixelData *)jarg1;
23962   {
23963     try {
23964       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23965     } catch (std::out_of_range& e) {
23966       {
23967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23968       };
23969     } catch (std::exception& e) {
23970       {
23971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23972       };
23973     } catch (Dali::DaliException e) {
23974       {
23975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23976       };
23977     } catch (...) {
23978       {
23979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23980       };
23981     }
23982   }
23983
23984   jresult = result;
23985   return jresult;
23986 }
23987
23988
23989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23990   int jresult ;
23991   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23992   Dali::Pixel::Format result;
23993
23994   arg1 = (Dali::PixelData *)jarg1;
23995   {
23996     try {
23997       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23998     } catch (std::out_of_range& e) {
23999       {
24000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24001       };
24002     } catch (std::exception& e) {
24003       {
24004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24005       };
24006     } catch (Dali::DaliException e) {
24007       {
24008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24009       };
24010     } catch (...) {
24011       {
24012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24013       };
24014     }
24015   }
24016
24017   jresult = (int)result;
24018   return jresult;
24019 }
24020
24021
24022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24023   unsigned int jresult ;
24024   unsigned int result;
24025
24026   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24027   jresult = result;
24028   return jresult;
24029 }
24030
24031
24032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24033   unsigned int jresult ;
24034   unsigned int result;
24035
24036   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24037   jresult = result;
24038   return jresult;
24039 }
24040
24041
24042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24043   unsigned int jresult ;
24044   unsigned int result;
24045
24046   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24047   jresult = result;
24048   return jresult;
24049 }
24050
24051
24052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24053   unsigned int jresult ;
24054   unsigned int result;
24055
24056   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24057   jresult = result;
24058   return jresult;
24059 }
24060
24061
24062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24063   unsigned int jresult ;
24064   unsigned int result;
24065
24066   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24067   jresult = result;
24068   return jresult;
24069 }
24070
24071
24072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24073   unsigned int jresult ;
24074   unsigned int result;
24075
24076   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24077   jresult = result;
24078   return jresult;
24079 }
24080
24081
24082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24083   void * jresult ;
24084   Dali::TextureType::Type arg1 ;
24085   Dali::Pixel::Format arg2 ;
24086   unsigned int arg3 ;
24087   unsigned int arg4 ;
24088   Dali::Texture result;
24089
24090   arg1 = (Dali::TextureType::Type)jarg1;
24091   arg2 = (Dali::Pixel::Format)jarg2;
24092   arg3 = (unsigned int)jarg3;
24093   arg4 = (unsigned int)jarg4;
24094   {
24095     try {
24096       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24097     } catch (std::out_of_range& e) {
24098       {
24099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24100       };
24101     } catch (std::exception& e) {
24102       {
24103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24104       };
24105     } catch (Dali::DaliException e) {
24106       {
24107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24108       };
24109     } catch (...) {
24110       {
24111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24112       };
24113     }
24114   }
24115
24116   jresult = new Dali::Texture((const Dali::Texture &)result);
24117   return jresult;
24118 }
24119
24120
24121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24122   void * jresult ;
24123   NativeImageInterface *arg1 = 0 ;
24124   Dali::Texture result;
24125
24126   arg1 = (NativeImageInterface *)jarg1;
24127   if (!arg1) {
24128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24129     return 0;
24130   }
24131   {
24132     try {
24133       result = Dali::Texture::New(*arg1);
24134     } catch (std::out_of_range& e) {
24135       {
24136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24137       };
24138     } catch (std::exception& e) {
24139       {
24140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24141       };
24142     } catch (Dali::DaliException e) {
24143       {
24144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24145       };
24146     } catch (...) {
24147       {
24148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24149       };
24150     }
24151   }
24152
24153   jresult = new Dali::Texture((const Dali::Texture &)result);
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24159   void * jresult ;
24160   Dali::Texture *result = 0 ;
24161
24162   {
24163     try {
24164       result = (Dali::Texture *)new Dali::Texture();
24165     } catch (std::out_of_range& e) {
24166       {
24167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24168       };
24169     } catch (std::exception& e) {
24170       {
24171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24172       };
24173     } catch (Dali::DaliException e) {
24174       {
24175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24176       };
24177     } catch (...) {
24178       {
24179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24180       };
24181     }
24182   }
24183
24184   jresult = (void *)result;
24185   return jresult;
24186 }
24187
24188
24189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24190   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24191
24192   arg1 = (Dali::Texture *)jarg1;
24193   {
24194     try {
24195       delete arg1;
24196     } catch (std::out_of_range& e) {
24197       {
24198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24199       };
24200     } catch (std::exception& e) {
24201       {
24202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24203       };
24204     } catch (Dali::DaliException e) {
24205       {
24206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24207       };
24208     } catch (...) {
24209       {
24210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24211       };
24212     }
24213   }
24214
24215 }
24216
24217
24218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24219   void * jresult ;
24220   Dali::Texture *arg1 = 0 ;
24221   Dali::Texture *result = 0 ;
24222
24223   arg1 = (Dali::Texture *)jarg1;
24224   if (!arg1) {
24225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24226     return 0;
24227   }
24228   {
24229     try {
24230       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24231     } catch (std::out_of_range& e) {
24232       {
24233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24234       };
24235     } catch (std::exception& e) {
24236       {
24237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24238       };
24239     } catch (Dali::DaliException e) {
24240       {
24241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24242       };
24243     } catch (...) {
24244       {
24245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24246       };
24247     }
24248   }
24249
24250   jresult = (void *)result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24256   void * jresult ;
24257   Dali::BaseHandle arg1 ;
24258   Dali::BaseHandle *argp1 ;
24259   Dali::Texture result;
24260
24261   argp1 = (Dali::BaseHandle *)jarg1;
24262   if (!argp1) {
24263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24264     return 0;
24265   }
24266   arg1 = *argp1;
24267   {
24268     try {
24269       result = Dali::Texture::DownCast(arg1);
24270     } catch (std::out_of_range& e) {
24271       {
24272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24273       };
24274     } catch (std::exception& e) {
24275       {
24276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24277       };
24278     } catch (Dali::DaliException e) {
24279       {
24280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24281       };
24282     } catch (...) {
24283       {
24284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24285       };
24286     }
24287   }
24288
24289   jresult = new Dali::Texture((const Dali::Texture &)result);
24290   return jresult;
24291 }
24292
24293
24294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24295   void * jresult ;
24296   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24297   Dali::Texture *arg2 = 0 ;
24298   Dali::Texture *result = 0 ;
24299
24300   arg1 = (Dali::Texture *)jarg1;
24301   arg2 = (Dali::Texture *)jarg2;
24302   if (!arg2) {
24303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24304     return 0;
24305   }
24306   {
24307     try {
24308       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24309     } catch (std::out_of_range& e) {
24310       {
24311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24312       };
24313     } catch (std::exception& e) {
24314       {
24315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24316       };
24317     } catch (Dali::DaliException e) {
24318       {
24319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24320       };
24321     } catch (...) {
24322       {
24323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24324       };
24325     }
24326   }
24327
24328   jresult = (void *)result;
24329   return jresult;
24330 }
24331
24332
24333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24334   unsigned int jresult ;
24335   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24336   Dali::PixelData arg2 ;
24337   Dali::PixelData *argp2 ;
24338   bool result;
24339
24340   arg1 = (Dali::Texture *)jarg1;
24341   argp2 = (Dali::PixelData *)jarg2;
24342   if (!argp2) {
24343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24344     return 0;
24345   }
24346   arg2 = *argp2;
24347   {
24348     try {
24349       result = (bool)(arg1)->Upload(arg2);
24350     } catch (std::out_of_range& e) {
24351       {
24352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24353       };
24354     } catch (std::exception& e) {
24355       {
24356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24357       };
24358     } catch (Dali::DaliException e) {
24359       {
24360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24361       };
24362     } catch (...) {
24363       {
24364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24365       };
24366     }
24367   }
24368
24369   jresult = result;
24370   return jresult;
24371 }
24372
24373
24374 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) {
24375   unsigned int jresult ;
24376   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24377   Dali::PixelData arg2 ;
24378   unsigned int arg3 ;
24379   unsigned int arg4 ;
24380   unsigned int arg5 ;
24381   unsigned int arg6 ;
24382   unsigned int arg7 ;
24383   unsigned int arg8 ;
24384   Dali::PixelData *argp2 ;
24385   bool result;
24386
24387   arg1 = (Dali::Texture *)jarg1;
24388   argp2 = (Dali::PixelData *)jarg2;
24389   if (!argp2) {
24390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24391     return 0;
24392   }
24393   arg2 = *argp2;
24394   arg3 = (unsigned int)jarg3;
24395   arg4 = (unsigned int)jarg4;
24396   arg5 = (unsigned int)jarg5;
24397   arg6 = (unsigned int)jarg6;
24398   arg7 = (unsigned int)jarg7;
24399   arg8 = (unsigned int)jarg8;
24400   {
24401     try {
24402       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24403     } catch (std::out_of_range& e) {
24404       {
24405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24406       };
24407     } catch (std::exception& e) {
24408       {
24409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24410       };
24411     } catch (Dali::DaliException e) {
24412       {
24413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24414       };
24415     } catch (...) {
24416       {
24417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24418       };
24419     }
24420   }
24421
24422   jresult = result;
24423   return jresult;
24424 }
24425
24426
24427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24428   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24429
24430   arg1 = (Dali::Texture *)jarg1;
24431   {
24432     try {
24433       (arg1)->GenerateMipmaps();
24434     } catch (std::out_of_range& e) {
24435       {
24436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24437       };
24438     } catch (std::exception& e) {
24439       {
24440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24441       };
24442     } catch (Dali::DaliException e) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24445       };
24446     } catch (...) {
24447       {
24448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24449       };
24450     }
24451   }
24452
24453 }
24454
24455
24456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24457   unsigned int jresult ;
24458   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24459   unsigned int result;
24460
24461   arg1 = (Dali::Texture *)jarg1;
24462   {
24463     try {
24464       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24465     } catch (std::out_of_range& e) {
24466       {
24467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (std::exception& e) {
24470       {
24471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24472       };
24473     } catch (Dali::DaliException e) {
24474       {
24475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24476       };
24477     } catch (...) {
24478       {
24479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24480       };
24481     }
24482   }
24483
24484   jresult = result;
24485   return jresult;
24486 }
24487
24488
24489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24490   unsigned int jresult ;
24491   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24492   unsigned int result;
24493
24494   arg1 = (Dali::Texture *)jarg1;
24495   {
24496     try {
24497       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24498     } catch (std::out_of_range& e) {
24499       {
24500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24501       };
24502     } catch (std::exception& e) {
24503       {
24504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24505       };
24506     } catch (Dali::DaliException e) {
24507       {
24508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24509       };
24510     } catch (...) {
24511       {
24512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24513       };
24514     }
24515   }
24516
24517   jresult = result;
24518   return jresult;
24519 }
24520
24521
24522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24523   void * jresult ;
24524   Dali::Sampler result;
24525
24526   {
24527     try {
24528       result = Dali::Sampler::New();
24529     } catch (std::out_of_range& e) {
24530       {
24531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (std::exception& e) {
24534       {
24535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24536       };
24537     } catch (Dali::DaliException e) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24540       };
24541     } catch (...) {
24542       {
24543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24544       };
24545     }
24546   }
24547
24548   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24549   return jresult;
24550 }
24551
24552
24553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24554   void * jresult ;
24555   Dali::Sampler *result = 0 ;
24556
24557   {
24558     try {
24559       result = (Dali::Sampler *)new Dali::Sampler();
24560     } catch (std::out_of_range& e) {
24561       {
24562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24563       };
24564     } catch (std::exception& e) {
24565       {
24566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24567       };
24568     } catch (Dali::DaliException e) {
24569       {
24570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24571       };
24572     } catch (...) {
24573       {
24574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24575       };
24576     }
24577   }
24578
24579   jresult = (void *)result;
24580   return jresult;
24581 }
24582
24583
24584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24585   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24586
24587   arg1 = (Dali::Sampler *)jarg1;
24588   {
24589     try {
24590       delete arg1;
24591     } catch (std::out_of_range& e) {
24592       {
24593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24594       };
24595     } catch (std::exception& e) {
24596       {
24597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24598       };
24599     } catch (Dali::DaliException e) {
24600       {
24601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24602       };
24603     } catch (...) {
24604       {
24605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24606       };
24607     }
24608   }
24609
24610 }
24611
24612
24613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24614   void * jresult ;
24615   Dali::Sampler *arg1 = 0 ;
24616   Dali::Sampler *result = 0 ;
24617
24618   arg1 = (Dali::Sampler *)jarg1;
24619   if (!arg1) {
24620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24621     return 0;
24622   }
24623   {
24624     try {
24625       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = (void *)result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24651   void * jresult ;
24652   Dali::BaseHandle arg1 ;
24653   Dali::BaseHandle *argp1 ;
24654   Dali::Sampler result;
24655
24656   argp1 = (Dali::BaseHandle *)jarg1;
24657   if (!argp1) {
24658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24659     return 0;
24660   }
24661   arg1 = *argp1;
24662   {
24663     try {
24664       result = Dali::Sampler::DownCast(arg1);
24665     } catch (std::out_of_range& e) {
24666       {
24667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24668       };
24669     } catch (std::exception& e) {
24670       {
24671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24672       };
24673     } catch (Dali::DaliException e) {
24674       {
24675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24676       };
24677     } catch (...) {
24678       {
24679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24680       };
24681     }
24682   }
24683
24684   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24685   return jresult;
24686 }
24687
24688
24689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24690   void * jresult ;
24691   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24692   Dali::Sampler *arg2 = 0 ;
24693   Dali::Sampler *result = 0 ;
24694
24695   arg1 = (Dali::Sampler *)jarg1;
24696   arg2 = (Dali::Sampler *)jarg2;
24697   if (!arg2) {
24698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24699     return 0;
24700   }
24701   {
24702     try {
24703       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24704     } catch (std::out_of_range& e) {
24705       {
24706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24707       };
24708     } catch (std::exception& e) {
24709       {
24710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24711       };
24712     } catch (Dali::DaliException e) {
24713       {
24714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24719       };
24720     }
24721   }
24722
24723   jresult = (void *)result;
24724   return jresult;
24725 }
24726
24727
24728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24729   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24730   Dali::FilterMode::Type arg2 ;
24731   Dali::FilterMode::Type arg3 ;
24732
24733   arg1 = (Dali::Sampler *)jarg1;
24734   arg2 = (Dali::FilterMode::Type)jarg2;
24735   arg3 = (Dali::FilterMode::Type)jarg3;
24736   {
24737     try {
24738       (arg1)->SetFilterMode(arg2,arg3);
24739     } catch (std::out_of_range& e) {
24740       {
24741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24742       };
24743     } catch (std::exception& e) {
24744       {
24745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24746       };
24747     } catch (Dali::DaliException e) {
24748       {
24749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24750       };
24751     } catch (...) {
24752       {
24753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24754       };
24755     }
24756   }
24757
24758 }
24759
24760
24761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24762   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24763   Dali::WrapMode::Type arg2 ;
24764   Dali::WrapMode::Type arg3 ;
24765
24766   arg1 = (Dali::Sampler *)jarg1;
24767   arg2 = (Dali::WrapMode::Type)jarg2;
24768   arg3 = (Dali::WrapMode::Type)jarg3;
24769   {
24770     try {
24771       (arg1)->SetWrapMode(arg2,arg3);
24772     } catch (std::out_of_range& e) {
24773       {
24774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24775       };
24776     } catch (std::exception& e) {
24777       {
24778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24779       };
24780     } catch (Dali::DaliException e) {
24781       {
24782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24783       };
24784     } catch (...) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24787       };
24788     }
24789   }
24790
24791 }
24792
24793
24794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24795   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24796   Dali::WrapMode::Type arg2 ;
24797   Dali::WrapMode::Type arg3 ;
24798   Dali::WrapMode::Type arg4 ;
24799
24800   arg1 = (Dali::Sampler *)jarg1;
24801   arg2 = (Dali::WrapMode::Type)jarg2;
24802   arg3 = (Dali::WrapMode::Type)jarg3;
24803   arg4 = (Dali::WrapMode::Type)jarg4;
24804   {
24805     try {
24806       (arg1)->SetWrapMode(arg2,arg3,arg4);
24807     } catch (std::out_of_range& e) {
24808       {
24809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24810       };
24811     } catch (std::exception& e) {
24812       {
24813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (Dali::DaliException e) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24818       };
24819     } catch (...) {
24820       {
24821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24822       };
24823     }
24824   }
24825
24826 }
24827
24828
24829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24830   void * jresult ;
24831   Dali::TextureSet result;
24832
24833   {
24834     try {
24835       result = Dali::TextureSet::New();
24836     } catch (std::out_of_range& e) {
24837       {
24838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (std::exception& e) {
24841       {
24842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24843       };
24844     } catch (Dali::DaliException e) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24847       };
24848     } catch (...) {
24849       {
24850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24851       };
24852     }
24853   }
24854
24855   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24856   return jresult;
24857 }
24858
24859
24860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24861   void * jresult ;
24862   Dali::TextureSet *result = 0 ;
24863
24864   {
24865     try {
24866       result = (Dali::TextureSet *)new Dali::TextureSet();
24867     } catch (std::out_of_range& e) {
24868       {
24869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24870       };
24871     } catch (std::exception& e) {
24872       {
24873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24874       };
24875     } catch (Dali::DaliException e) {
24876       {
24877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24878       };
24879     } catch (...) {
24880       {
24881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24882       };
24883     }
24884   }
24885
24886   jresult = (void *)result;
24887   return jresult;
24888 }
24889
24890
24891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24892   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24893
24894   arg1 = (Dali::TextureSet *)jarg1;
24895   {
24896     try {
24897       delete arg1;
24898     } catch (std::out_of_range& e) {
24899       {
24900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24901       };
24902     } catch (std::exception& e) {
24903       {
24904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24905       };
24906     } catch (Dali::DaliException e) {
24907       {
24908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24909       };
24910     } catch (...) {
24911       {
24912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24913       };
24914     }
24915   }
24916
24917 }
24918
24919
24920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24921   void * jresult ;
24922   Dali::TextureSet *arg1 = 0 ;
24923   Dali::TextureSet *result = 0 ;
24924
24925   arg1 = (Dali::TextureSet *)jarg1;
24926   if (!arg1) {
24927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24928     return 0;
24929   }
24930   {
24931     try {
24932       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24933     } catch (std::out_of_range& e) {
24934       {
24935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (std::exception& e) {
24938       {
24939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24940       };
24941     } catch (Dali::DaliException e) {
24942       {
24943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24944       };
24945     } catch (...) {
24946       {
24947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24948       };
24949     }
24950   }
24951
24952   jresult = (void *)result;
24953   return jresult;
24954 }
24955
24956
24957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24958   void * jresult ;
24959   Dali::BaseHandle arg1 ;
24960   Dali::BaseHandle *argp1 ;
24961   Dali::TextureSet result;
24962
24963   argp1 = (Dali::BaseHandle *)jarg1;
24964   if (!argp1) {
24965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24966     return 0;
24967   }
24968   arg1 = *argp1;
24969   {
24970     try {
24971       result = Dali::TextureSet::DownCast(arg1);
24972     } catch (std::out_of_range& e) {
24973       {
24974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24975       };
24976     } catch (std::exception& e) {
24977       {
24978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24979       };
24980     } catch (Dali::DaliException e) {
24981       {
24982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24983       };
24984     } catch (...) {
24985       {
24986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24987       };
24988     }
24989   }
24990
24991   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24992   return jresult;
24993 }
24994
24995
24996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24997   void * jresult ;
24998   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24999   Dali::TextureSet *arg2 = 0 ;
25000   Dali::TextureSet *result = 0 ;
25001
25002   arg1 = (Dali::TextureSet *)jarg1;
25003   arg2 = (Dali::TextureSet *)jarg2;
25004   if (!arg2) {
25005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25006     return 0;
25007   }
25008   {
25009     try {
25010       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25011     } catch (std::out_of_range& e) {
25012       {
25013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25014       };
25015     } catch (std::exception& e) {
25016       {
25017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25018       };
25019     } catch (Dali::DaliException e) {
25020       {
25021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25022       };
25023     } catch (...) {
25024       {
25025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25026       };
25027     }
25028   }
25029
25030   jresult = (void *)result;
25031   return jresult;
25032 }
25033
25034
25035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25036   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25037   size_t arg2 ;
25038   Dali::Texture arg3 ;
25039   Dali::Texture *argp3 ;
25040
25041   arg1 = (Dali::TextureSet *)jarg1;
25042   arg2 = (size_t)jarg2;
25043   argp3 = (Dali::Texture *)jarg3;
25044   if (!argp3) {
25045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25046     return ;
25047   }
25048   arg3 = *argp3;
25049   {
25050     try {
25051       (arg1)->SetTexture(arg2,arg3);
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25067       };
25068     }
25069   }
25070
25071 }
25072
25073
25074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25075   void * jresult ;
25076   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25077   size_t arg2 ;
25078   Dali::Texture result;
25079
25080   arg1 = (Dali::TextureSet *)jarg1;
25081   arg2 = (size_t)jarg2;
25082   {
25083     try {
25084       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25085     } catch (std::out_of_range& e) {
25086       {
25087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25088       };
25089     } catch (std::exception& e) {
25090       {
25091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25092       };
25093     } catch (Dali::DaliException e) {
25094       {
25095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25096       };
25097     } catch (...) {
25098       {
25099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25100       };
25101     }
25102   }
25103
25104   jresult = new Dali::Texture((const Dali::Texture &)result);
25105   return jresult;
25106 }
25107
25108
25109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25110   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25111   size_t arg2 ;
25112   Dali::Sampler arg3 ;
25113   Dali::Sampler *argp3 ;
25114
25115   arg1 = (Dali::TextureSet *)jarg1;
25116   arg2 = (size_t)jarg2;
25117   argp3 = (Dali::Sampler *)jarg3;
25118   if (!argp3) {
25119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25120     return ;
25121   }
25122   arg3 = *argp3;
25123   {
25124     try {
25125       (arg1)->SetSampler(arg2,arg3);
25126     } catch (std::out_of_range& e) {
25127       {
25128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25129       };
25130     } catch (std::exception& e) {
25131       {
25132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25133       };
25134     } catch (Dali::DaliException e) {
25135       {
25136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25141       };
25142     }
25143   }
25144
25145 }
25146
25147
25148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25149   void * jresult ;
25150   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25151   size_t arg2 ;
25152   Dali::Sampler result;
25153
25154   arg1 = (Dali::TextureSet *)jarg1;
25155   arg2 = (size_t)jarg2;
25156   {
25157     try {
25158       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25159     } catch (std::out_of_range& e) {
25160       {
25161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (std::exception& e) {
25164       {
25165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25166       };
25167     } catch (Dali::DaliException e) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25170       };
25171     } catch (...) {
25172       {
25173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25174       };
25175     }
25176   }
25177
25178   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25184   unsigned long jresult ;
25185   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25186   size_t result;
25187
25188   arg1 = (Dali::TextureSet *)jarg1;
25189   {
25190     try {
25191       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25192     } catch (std::out_of_range& e) {
25193       {
25194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25195       };
25196     } catch (std::exception& e) {
25197       {
25198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (Dali::DaliException e) {
25201       {
25202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25203       };
25204     } catch (...) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25207       };
25208     }
25209   }
25210
25211   jresult = (unsigned long)result;
25212   return jresult;
25213 }
25214
25215
25216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25217   void * jresult ;
25218   Dali::Property::Map *arg1 = 0 ;
25219   Dali::PropertyBuffer result;
25220
25221   arg1 = (Dali::Property::Map *)jarg1;
25222   if (!arg1) {
25223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25224     return 0;
25225   }
25226   {
25227     try {
25228       result = Dali::PropertyBuffer::New(*arg1);
25229     } catch (std::out_of_range& e) {
25230       {
25231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (std::exception& e) {
25234       {
25235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25236       };
25237     } catch (Dali::DaliException e) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25240       };
25241     } catch (...) {
25242       {
25243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25244       };
25245     }
25246   }
25247
25248   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25249   return jresult;
25250 }
25251
25252
25253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25254   void * jresult ;
25255   Dali::PropertyBuffer *result = 0 ;
25256
25257   {
25258     try {
25259       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25260     } catch (std::out_of_range& e) {
25261       {
25262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25263       };
25264     } catch (std::exception& e) {
25265       {
25266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25267       };
25268     } catch (Dali::DaliException e) {
25269       {
25270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25271       };
25272     } catch (...) {
25273       {
25274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25275       };
25276     }
25277   }
25278
25279   jresult = (void *)result;
25280   return jresult;
25281 }
25282
25283
25284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25285   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25286
25287   arg1 = (Dali::PropertyBuffer *)jarg1;
25288   {
25289     try {
25290       delete arg1;
25291     } catch (std::out_of_range& e) {
25292       {
25293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25294       };
25295     } catch (std::exception& e) {
25296       {
25297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25298       };
25299     } catch (Dali::DaliException e) {
25300       {
25301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25302       };
25303     } catch (...) {
25304       {
25305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25306       };
25307     }
25308   }
25309
25310 }
25311
25312
25313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25314   void * jresult ;
25315   Dali::PropertyBuffer *arg1 = 0 ;
25316   Dali::PropertyBuffer *result = 0 ;
25317
25318   arg1 = (Dali::PropertyBuffer *)jarg1;
25319   if (!arg1) {
25320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25321     return 0;
25322   }
25323   {
25324     try {
25325       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25326     } catch (std::out_of_range& e) {
25327       {
25328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25329       };
25330     } catch (std::exception& e) {
25331       {
25332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25333       };
25334     } catch (Dali::DaliException e) {
25335       {
25336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25337       };
25338     } catch (...) {
25339       {
25340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25341       };
25342     }
25343   }
25344
25345   jresult = (void *)result;
25346   return jresult;
25347 }
25348
25349
25350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25351   void * jresult ;
25352   Dali::BaseHandle arg1 ;
25353   Dali::BaseHandle *argp1 ;
25354   Dali::PropertyBuffer result;
25355
25356   argp1 = (Dali::BaseHandle *)jarg1;
25357   if (!argp1) {
25358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25359     return 0;
25360   }
25361   arg1 = *argp1;
25362   {
25363     try {
25364       result = Dali::PropertyBuffer::DownCast(arg1);
25365     } catch (std::out_of_range& e) {
25366       {
25367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25368       };
25369     } catch (std::exception& e) {
25370       {
25371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25372       };
25373     } catch (Dali::DaliException e) {
25374       {
25375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25376       };
25377     } catch (...) {
25378       {
25379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25380       };
25381     }
25382   }
25383
25384   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25385   return jresult;
25386 }
25387
25388
25389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25390   void * jresult ;
25391   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25392   Dali::PropertyBuffer *arg2 = 0 ;
25393   Dali::PropertyBuffer *result = 0 ;
25394
25395   arg1 = (Dali::PropertyBuffer *)jarg1;
25396   arg2 = (Dali::PropertyBuffer *)jarg2;
25397   if (!arg2) {
25398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25399     return 0;
25400   }
25401   {
25402     try {
25403       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25404     } catch (std::out_of_range& e) {
25405       {
25406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25407       };
25408     } catch (std::exception& e) {
25409       {
25410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25411       };
25412     } catch (Dali::DaliException e) {
25413       {
25414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25419       };
25420     }
25421   }
25422
25423   jresult = (void *)result;
25424   return jresult;
25425 }
25426
25427
25428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25429   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25430   void *arg2 = (void *) 0 ;
25431   std::size_t arg3 ;
25432
25433   arg1 = (Dali::PropertyBuffer *)jarg1;
25434   arg2 = jarg2;
25435   arg3 = (std::size_t)jarg3;
25436   {
25437     try {
25438       (arg1)->SetData((void const *)arg2,arg3);
25439     } catch (std::out_of_range& e) {
25440       {
25441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25442       };
25443     } catch (std::exception& e) {
25444       {
25445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25446       };
25447     } catch (Dali::DaliException e) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25450       };
25451     } catch (...) {
25452       {
25453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25454       };
25455     }
25456   }
25457
25458 }
25459
25460
25461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25462   unsigned long jresult ;
25463   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25464   std::size_t result;
25465
25466   arg1 = (Dali::PropertyBuffer *)jarg1;
25467   {
25468     try {
25469       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25470     } catch (std::out_of_range& e) {
25471       {
25472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25473       };
25474     } catch (std::exception& e) {
25475       {
25476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25477       };
25478     } catch (Dali::DaliException e) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25481       };
25482     } catch (...) {
25483       {
25484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25485       };
25486     }
25487   }
25488
25489   jresult = (unsigned long)result;
25490   return jresult;
25491 }
25492
25493
25494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25495   void * jresult ;
25496   Dali::Geometry result;
25497
25498   {
25499     try {
25500       result = Dali::Geometry::New();
25501     } catch (std::out_of_range& e) {
25502       {
25503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (std::exception& e) {
25506       {
25507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25508       };
25509     } catch (Dali::DaliException e) {
25510       {
25511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25512       };
25513     } catch (...) {
25514       {
25515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25516       };
25517     }
25518   }
25519
25520   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25521   return jresult;
25522 }
25523
25524
25525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25526   void * jresult ;
25527   Dali::Geometry *result = 0 ;
25528
25529   {
25530     try {
25531       result = (Dali::Geometry *)new Dali::Geometry();
25532     } catch (std::out_of_range& e) {
25533       {
25534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25535       };
25536     } catch (std::exception& e) {
25537       {
25538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25539       };
25540     } catch (Dali::DaliException e) {
25541       {
25542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25543       };
25544     } catch (...) {
25545       {
25546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25547       };
25548     }
25549   }
25550
25551   jresult = (void *)result;
25552   return jresult;
25553 }
25554
25555
25556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25557   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25558
25559   arg1 = (Dali::Geometry *)jarg1;
25560   {
25561     try {
25562       delete arg1;
25563     } catch (std::out_of_range& e) {
25564       {
25565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25566       };
25567     } catch (std::exception& e) {
25568       {
25569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25570       };
25571     } catch (Dali::DaliException e) {
25572       {
25573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25574       };
25575     } catch (...) {
25576       {
25577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25578       };
25579     }
25580   }
25581
25582 }
25583
25584
25585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25586   void * jresult ;
25587   Dali::Geometry *arg1 = 0 ;
25588   Dali::Geometry *result = 0 ;
25589
25590   arg1 = (Dali::Geometry *)jarg1;
25591   if (!arg1) {
25592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25593     return 0;
25594   }
25595   {
25596     try {
25597       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25598     } catch (std::out_of_range& e) {
25599       {
25600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25601       };
25602     } catch (std::exception& e) {
25603       {
25604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25605       };
25606     } catch (Dali::DaliException e) {
25607       {
25608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25609       };
25610     } catch (...) {
25611       {
25612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25613       };
25614     }
25615   }
25616
25617   jresult = (void *)result;
25618   return jresult;
25619 }
25620
25621
25622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25623   void * jresult ;
25624   Dali::BaseHandle arg1 ;
25625   Dali::BaseHandle *argp1 ;
25626   Dali::Geometry result;
25627
25628   argp1 = (Dali::BaseHandle *)jarg1;
25629   if (!argp1) {
25630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25631     return 0;
25632   }
25633   arg1 = *argp1;
25634   {
25635     try {
25636       result = Dali::Geometry::DownCast(arg1);
25637     } catch (std::out_of_range& e) {
25638       {
25639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25640       };
25641     } catch (std::exception& e) {
25642       {
25643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25644       };
25645     } catch (Dali::DaliException e) {
25646       {
25647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25648       };
25649     } catch (...) {
25650       {
25651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25652       };
25653     }
25654   }
25655
25656   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25657   return jresult;
25658 }
25659
25660
25661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25662   void * jresult ;
25663   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25664   Dali::Geometry *arg2 = 0 ;
25665   Dali::Geometry *result = 0 ;
25666
25667   arg1 = (Dali::Geometry *)jarg1;
25668   arg2 = (Dali::Geometry *)jarg2;
25669   if (!arg2) {
25670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25671     return 0;
25672   }
25673   {
25674     try {
25675       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25676     } catch (std::out_of_range& e) {
25677       {
25678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25679       };
25680     } catch (std::exception& e) {
25681       {
25682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25683       };
25684     } catch (Dali::DaliException e) {
25685       {
25686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25687       };
25688     } catch (...) {
25689       {
25690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25691       };
25692     }
25693   }
25694
25695   jresult = (void *)result;
25696   return jresult;
25697 }
25698
25699
25700 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25701   unsigned long jresult ;
25702   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25703   Dali::PropertyBuffer *arg2 = 0 ;
25704   std::size_t result;
25705
25706   arg1 = (Dali::Geometry *)jarg1;
25707   arg2 = (Dali::PropertyBuffer *)jarg2;
25708   if (!arg2) {
25709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25710     return 0;
25711   }
25712   {
25713     try {
25714       result = (arg1)->AddVertexBuffer(*arg2);
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25722       };
25723     } catch (Dali::DaliException e) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25726       };
25727     } catch (...) {
25728       {
25729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25730       };
25731     }
25732   }
25733
25734   jresult = (unsigned long)result;
25735   return jresult;
25736 }
25737
25738
25739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25740   unsigned long jresult ;
25741   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25742   std::size_t result;
25743
25744   arg1 = (Dali::Geometry *)jarg1;
25745   {
25746     try {
25747       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25763       };
25764     }
25765   }
25766
25767   jresult = (unsigned long)result;
25768   return jresult;
25769 }
25770
25771
25772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25773   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25774   std::size_t arg2 ;
25775
25776   arg1 = (Dali::Geometry *)jarg1;
25777   arg2 = (std::size_t)jarg2;
25778   {
25779     try {
25780       (arg1)->RemoveVertexBuffer(arg2);
25781     } catch (std::out_of_range& e) {
25782       {
25783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25784       };
25785     } catch (std::exception& e) {
25786       {
25787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25788       };
25789     } catch (Dali::DaliException e) {
25790       {
25791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25792       };
25793     } catch (...) {
25794       {
25795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25796       };
25797     }
25798   }
25799
25800 }
25801
25802
25803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25804   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25805   unsigned short *arg2 = (unsigned short *) 0 ;
25806   size_t arg3 ;
25807
25808   arg1 = (Dali::Geometry *)jarg1;
25809   arg2 = jarg2;
25810   arg3 = (size_t)jarg3;
25811   {
25812     try {
25813       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25814     } catch (std::out_of_range& e) {
25815       {
25816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25817       };
25818     } catch (std::exception& e) {
25819       {
25820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25821       };
25822     } catch (Dali::DaliException e) {
25823       {
25824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25825       };
25826     } catch (...) {
25827       {
25828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25829       };
25830     }
25831   }
25832
25833
25834
25835 }
25836
25837
25838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25839   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25840   Dali::Geometry::Type arg2 ;
25841
25842   arg1 = (Dali::Geometry *)jarg1;
25843   arg2 = (Dali::Geometry::Type)jarg2;
25844   {
25845     try {
25846       (arg1)->SetType(arg2);
25847     } catch (std::out_of_range& e) {
25848       {
25849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25850       };
25851     } catch (std::exception& e) {
25852       {
25853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25854       };
25855     } catch (Dali::DaliException e) {
25856       {
25857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25858       };
25859     } catch (...) {
25860       {
25861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25862       };
25863     }
25864   }
25865
25866 }
25867
25868
25869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25870   int jresult ;
25871   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25872   Dali::Geometry::Type result;
25873
25874   arg1 = (Dali::Geometry *)jarg1;
25875   {
25876     try {
25877       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25878     } catch (std::out_of_range& e) {
25879       {
25880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (std::exception& e) {
25883       {
25884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25885       };
25886     } catch (Dali::DaliException e) {
25887       {
25888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25889       };
25890     } catch (...) {
25891       {
25892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25893       };
25894     }
25895   }
25896
25897   jresult = (int)result;
25898   return jresult;
25899 }
25900
25901
25902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25903   void * jresult ;
25904   Dali::Shader::Hint *result = 0 ;
25905
25906   {
25907     try {
25908       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25909     } catch (std::out_of_range& e) {
25910       {
25911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25912       };
25913     } catch (std::exception& e) {
25914       {
25915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25916       };
25917     } catch (Dali::DaliException e) {
25918       {
25919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25920       };
25921     } catch (...) {
25922       {
25923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25924       };
25925     }
25926   }
25927
25928   jresult = (void *)result;
25929   return jresult;
25930 }
25931
25932
25933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25934   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25935
25936   arg1 = (Dali::Shader::Hint *)jarg1;
25937   {
25938     try {
25939       delete arg1;
25940     } catch (std::out_of_range& e) {
25941       {
25942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25943       };
25944     } catch (std::exception& e) {
25945       {
25946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25947       };
25948     } catch (Dali::DaliException e) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25951       };
25952     } catch (...) {
25953       {
25954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25955       };
25956     }
25957   }
25958
25959 }
25960
25961
25962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25963   int jresult ;
25964   int result;
25965
25966   result = (int)Dali::Shader::Property::PROGRAM;
25967   jresult = (int)result;
25968   return jresult;
25969 }
25970
25971
25972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25973   void * jresult ;
25974   Dali::Shader::Property *result = 0 ;
25975
25976   {
25977     try {
25978       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25979     } catch (std::out_of_range& e) {
25980       {
25981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25982       };
25983     } catch (std::exception& e) {
25984       {
25985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25986       };
25987     } catch (Dali::DaliException e) {
25988       {
25989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25990       };
25991     } catch (...) {
25992       {
25993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25994       };
25995     }
25996   }
25997
25998   jresult = (void *)result;
25999   return jresult;
26000 }
26001
26002
26003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26004   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26005
26006   arg1 = (Dali::Shader::Property *)jarg1;
26007   {
26008     try {
26009       delete arg1;
26010     } catch (std::out_of_range& e) {
26011       {
26012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26013       };
26014     } catch (std::exception& e) {
26015       {
26016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26017       };
26018     } catch (Dali::DaliException e) {
26019       {
26020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26021       };
26022     } catch (...) {
26023       {
26024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26025       };
26026     }
26027   }
26028
26029 }
26030
26031
26032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26033   void * jresult ;
26034   std::string *arg1 = 0 ;
26035   std::string *arg2 = 0 ;
26036   Dali::Shader::Hint::Value arg3 ;
26037   Dali::Shader result;
26038
26039   if (!jarg1) {
26040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26041     return 0;
26042   }
26043   std::string arg1_str(jarg1);
26044   arg1 = &arg1_str;
26045   if (!jarg2) {
26046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26047     return 0;
26048   }
26049   std::string arg2_str(jarg2);
26050   arg2 = &arg2_str;
26051   arg3 = (Dali::Shader::Hint::Value)jarg3;
26052   {
26053     try {
26054       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26055     } catch (std::out_of_range& e) {
26056       {
26057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26058       };
26059     } catch (std::exception& e) {
26060       {
26061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26062       };
26063     } catch (Dali::DaliException e) {
26064       {
26065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26066       };
26067     } catch (...) {
26068       {
26069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26070       };
26071     }
26072   }
26073
26074   jresult = new Dali::Shader((const Dali::Shader &)result);
26075
26076   //argout typemap for const std::string&
26077
26078
26079   //argout typemap for const std::string&
26080
26081   return jresult;
26082 }
26083
26084
26085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26086   void * jresult ;
26087   std::string *arg1 = 0 ;
26088   std::string *arg2 = 0 ;
26089   Dali::Shader result;
26090
26091   if (!jarg1) {
26092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26093     return 0;
26094   }
26095   std::string arg1_str(jarg1);
26096   arg1 = &arg1_str;
26097   if (!jarg2) {
26098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26099     return 0;
26100   }
26101   std::string arg2_str(jarg2);
26102   arg2 = &arg2_str;
26103   {
26104     try {
26105       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26106     } catch (std::out_of_range& e) {
26107       {
26108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26109       };
26110     } catch (std::exception& e) {
26111       {
26112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (Dali::DaliException e) {
26115       {
26116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26117       };
26118     } catch (...) {
26119       {
26120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26121       };
26122     }
26123   }
26124
26125   jresult = new Dali::Shader((const Dali::Shader &)result);
26126
26127   //argout typemap for const std::string&
26128
26129
26130   //argout typemap for const std::string&
26131
26132   return jresult;
26133 }
26134
26135
26136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26137   void * jresult ;
26138   Dali::Shader *result = 0 ;
26139
26140   {
26141     try {
26142       result = (Dali::Shader *)new Dali::Shader();
26143     } catch (std::out_of_range& e) {
26144       {
26145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26146       };
26147     } catch (std::exception& e) {
26148       {
26149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26150       };
26151     } catch (Dali::DaliException e) {
26152       {
26153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26154       };
26155     } catch (...) {
26156       {
26157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26158       };
26159     }
26160   }
26161
26162   jresult = (void *)result;
26163   return jresult;
26164 }
26165
26166
26167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26168   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26169
26170   arg1 = (Dali::Shader *)jarg1;
26171   {
26172     try {
26173       delete arg1;
26174     } catch (std::out_of_range& e) {
26175       {
26176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26177       };
26178     } catch (std::exception& e) {
26179       {
26180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26181       };
26182     } catch (Dali::DaliException e) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26185       };
26186     } catch (...) {
26187       {
26188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26189       };
26190     }
26191   }
26192
26193 }
26194
26195
26196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26197   void * jresult ;
26198   Dali::Shader *arg1 = 0 ;
26199   Dali::Shader *result = 0 ;
26200
26201   arg1 = (Dali::Shader *)jarg1;
26202   if (!arg1) {
26203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26204     return 0;
26205   }
26206   {
26207     try {
26208       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26209     } catch (std::out_of_range& e) {
26210       {
26211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26212       };
26213     } catch (std::exception& e) {
26214       {
26215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26216       };
26217     } catch (Dali::DaliException e) {
26218       {
26219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26220       };
26221     } catch (...) {
26222       {
26223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26224       };
26225     }
26226   }
26227
26228   jresult = (void *)result;
26229   return jresult;
26230 }
26231
26232
26233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26234   void * jresult ;
26235   Dali::BaseHandle arg1 ;
26236   Dali::BaseHandle *argp1 ;
26237   Dali::Shader result;
26238
26239   argp1 = (Dali::BaseHandle *)jarg1;
26240   if (!argp1) {
26241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26242     return 0;
26243   }
26244   arg1 = *argp1;
26245   {
26246     try {
26247       result = Dali::Shader::DownCast(arg1);
26248     } catch (std::out_of_range& e) {
26249       {
26250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26251       };
26252     } catch (std::exception& e) {
26253       {
26254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26255       };
26256     } catch (Dali::DaliException e) {
26257       {
26258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26259       };
26260     } catch (...) {
26261       {
26262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26263       };
26264     }
26265   }
26266
26267   jresult = new Dali::Shader((const Dali::Shader &)result);
26268   return jresult;
26269 }
26270
26271
26272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26273   void * jresult ;
26274   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26275   Dali::Shader *arg2 = 0 ;
26276   Dali::Shader *result = 0 ;
26277
26278   arg1 = (Dali::Shader *)jarg1;
26279   arg2 = (Dali::Shader *)jarg2;
26280   if (!arg2) {
26281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26282     return 0;
26283   }
26284   {
26285     try {
26286       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26287     } catch (std::out_of_range& e) {
26288       {
26289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26290       };
26291     } catch (std::exception& e) {
26292       {
26293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26294       };
26295     } catch (Dali::DaliException e) {
26296       {
26297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26298       };
26299     } catch (...) {
26300       {
26301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26302       };
26303     }
26304   }
26305
26306   jresult = (void *)result;
26307   return jresult;
26308 }
26309
26310
26311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26312   int jresult ;
26313   int result;
26314
26315   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26316   jresult = (int)result;
26317   return jresult;
26318 }
26319
26320
26321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26322   int jresult ;
26323   int result;
26324
26325   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26326   jresult = (int)result;
26327   return jresult;
26328 }
26329
26330
26331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26332   int jresult ;
26333   int result;
26334
26335   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26336   jresult = (int)result;
26337   return jresult;
26338 }
26339
26340
26341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26342   int jresult ;
26343   int result;
26344
26345   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26346   jresult = (int)result;
26347   return jresult;
26348 }
26349
26350
26351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26352   int jresult ;
26353   int result;
26354
26355   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26356   jresult = (int)result;
26357   return jresult;
26358 }
26359
26360
26361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26362   int jresult ;
26363   int result;
26364
26365   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26366   jresult = (int)result;
26367   return jresult;
26368 }
26369
26370
26371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26372   int jresult ;
26373   int result;
26374
26375   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26376   jresult = (int)result;
26377   return jresult;
26378 }
26379
26380
26381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26382   int jresult ;
26383   int result;
26384
26385   result = (int)Dali::Renderer::Property::BLEND_MODE;
26386   jresult = (int)result;
26387   return jresult;
26388 }
26389
26390
26391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26392   int jresult ;
26393   int result;
26394
26395   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26396   jresult = (int)result;
26397   return jresult;
26398 }
26399
26400
26401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26402   int jresult ;
26403   int result;
26404
26405   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26406   jresult = (int)result;
26407   return jresult;
26408 }
26409
26410
26411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26412   int jresult ;
26413   int result;
26414
26415   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26416   jresult = (int)result;
26417   return jresult;
26418 }
26419
26420
26421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26422   int jresult ;
26423   int result;
26424
26425   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26426   jresult = (int)result;
26427   return jresult;
26428 }
26429
26430
26431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26432   int jresult ;
26433   int result;
26434
26435   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26436   jresult = (int)result;
26437   return jresult;
26438 }
26439
26440
26441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26442   int jresult ;
26443   int result;
26444
26445   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26446   jresult = (int)result;
26447   return jresult;
26448 }
26449
26450
26451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26452   int jresult ;
26453   int result;
26454
26455   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26456   jresult = (int)result;
26457   return jresult;
26458 }
26459
26460
26461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26462   int jresult ;
26463   int result;
26464
26465   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26466   jresult = (int)result;
26467   return jresult;
26468 }
26469
26470
26471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26472   int jresult ;
26473   int result;
26474
26475   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26476   jresult = (int)result;
26477   return jresult;
26478 }
26479
26480
26481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26482   int jresult ;
26483   int result;
26484
26485   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26486   jresult = (int)result;
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26492   int jresult ;
26493   int result;
26494
26495   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26496   jresult = (int)result;
26497   return jresult;
26498 }
26499
26500
26501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26502   int jresult ;
26503   int result;
26504
26505   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26506   jresult = (int)result;
26507   return jresult;
26508 }
26509
26510
26511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26512   int jresult ;
26513   int result;
26514
26515   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26516   jresult = (int)result;
26517   return jresult;
26518 }
26519
26520
26521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26522   int jresult ;
26523   int result;
26524
26525   result = (int)Dali::Renderer::Property::RENDER_MODE;
26526   jresult = (int)result;
26527   return jresult;
26528 }
26529
26530
26531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26532   int jresult ;
26533   int result;
26534
26535   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26536   jresult = (int)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26542   int jresult ;
26543   int result;
26544
26545   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26546   jresult = (int)result;
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26552   int jresult ;
26553   int result;
26554
26555   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26556   jresult = (int)result;
26557   return jresult;
26558 }
26559
26560
26561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26562   int jresult ;
26563   int result;
26564
26565   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26566   jresult = (int)result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26572   int jresult ;
26573   int result;
26574
26575   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26576   jresult = (int)result;
26577   return jresult;
26578 }
26579
26580
26581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26582   int jresult ;
26583   int result;
26584
26585   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26586   jresult = (int)result;
26587   return jresult;
26588 }
26589
26590
26591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26592   int jresult ;
26593   int result;
26594
26595   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26596   jresult = (int)result;
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26602   void * jresult ;
26603   Dali::Renderer::Property *result = 0 ;
26604
26605   {
26606     try {
26607       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26608     } catch (std::out_of_range& e) {
26609       {
26610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26611       };
26612     } catch (std::exception& e) {
26613       {
26614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26615       };
26616     } catch (Dali::DaliException e) {
26617       {
26618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26619       };
26620     } catch (...) {
26621       {
26622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26623       };
26624     }
26625   }
26626
26627   jresult = (void *)result;
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26633   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26634
26635   arg1 = (Dali::Renderer::Property *)jarg1;
26636   {
26637     try {
26638       delete arg1;
26639     } catch (std::out_of_range& e) {
26640       {
26641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26642       };
26643     } catch (std::exception& e) {
26644       {
26645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26646       };
26647     } catch (Dali::DaliException e) {
26648       {
26649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26650       };
26651     } catch (...) {
26652       {
26653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26654       };
26655     }
26656   }
26657
26658 }
26659
26660
26661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26662   void * jresult ;
26663   Dali::Geometry *arg1 = 0 ;
26664   Dali::Shader *arg2 = 0 ;
26665   Dali::Renderer result;
26666
26667   arg1 = (Dali::Geometry *)jarg1;
26668   if (!arg1) {
26669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26670     return 0;
26671   }
26672   arg2 = (Dali::Shader *)jarg2;
26673   if (!arg2) {
26674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26675     return 0;
26676   }
26677   {
26678     try {
26679       result = Dali::Renderer::New(*arg1,*arg2);
26680     } catch (std::out_of_range& e) {
26681       {
26682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26683       };
26684     } catch (std::exception& e) {
26685       {
26686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26687       };
26688     } catch (Dali::DaliException e) {
26689       {
26690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26691       };
26692     } catch (...) {
26693       {
26694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26695       };
26696     }
26697   }
26698
26699   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26705   void * jresult ;
26706   Dali::Renderer *result = 0 ;
26707
26708   {
26709     try {
26710       result = (Dali::Renderer *)new Dali::Renderer();
26711     } catch (std::out_of_range& e) {
26712       {
26713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26714       };
26715     } catch (std::exception& e) {
26716       {
26717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26718       };
26719     } catch (Dali::DaliException e) {
26720       {
26721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26722       };
26723     } catch (...) {
26724       {
26725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26726       };
26727     }
26728   }
26729
26730   jresult = (void *)result;
26731   return jresult;
26732 }
26733
26734
26735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26736   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26737
26738   arg1 = (Dali::Renderer *)jarg1;
26739   {
26740     try {
26741       delete arg1;
26742     } catch (std::out_of_range& e) {
26743       {
26744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26745       };
26746     } catch (std::exception& e) {
26747       {
26748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26749       };
26750     } catch (Dali::DaliException e) {
26751       {
26752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26753       };
26754     } catch (...) {
26755       {
26756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26757       };
26758     }
26759   }
26760
26761 }
26762
26763
26764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26765   void * jresult ;
26766   Dali::Renderer *arg1 = 0 ;
26767   Dali::Renderer *result = 0 ;
26768
26769   arg1 = (Dali::Renderer *)jarg1;
26770   if (!arg1) {
26771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26772     return 0;
26773   }
26774   {
26775     try {
26776       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = (void *)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26802   void * jresult ;
26803   Dali::BaseHandle arg1 ;
26804   Dali::BaseHandle *argp1 ;
26805   Dali::Renderer result;
26806
26807   argp1 = (Dali::BaseHandle *)jarg1;
26808   if (!argp1) {
26809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26810     return 0;
26811   }
26812   arg1 = *argp1;
26813   {
26814     try {
26815       result = Dali::Renderer::DownCast(arg1);
26816     } catch (std::out_of_range& e) {
26817       {
26818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26819       };
26820     } catch (std::exception& e) {
26821       {
26822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26823       };
26824     } catch (Dali::DaliException e) {
26825       {
26826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26827       };
26828     } catch (...) {
26829       {
26830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26831       };
26832     }
26833   }
26834
26835   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26836   return jresult;
26837 }
26838
26839
26840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26841   void * jresult ;
26842   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26843   Dali::Renderer *arg2 = 0 ;
26844   Dali::Renderer *result = 0 ;
26845
26846   arg1 = (Dali::Renderer *)jarg1;
26847   arg2 = (Dali::Renderer *)jarg2;
26848   if (!arg2) {
26849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26850     return 0;
26851   }
26852   {
26853     try {
26854       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26855     } catch (std::out_of_range& e) {
26856       {
26857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26858       };
26859     } catch (std::exception& e) {
26860       {
26861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26862       };
26863     } catch (Dali::DaliException e) {
26864       {
26865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26866       };
26867     } catch (...) {
26868       {
26869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26870       };
26871     }
26872   }
26873
26874   jresult = (void *)result;
26875   return jresult;
26876 }
26877
26878
26879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26880   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26881   Dali::Geometry *arg2 = 0 ;
26882
26883   arg1 = (Dali::Renderer *)jarg1;
26884   arg2 = (Dali::Geometry *)jarg2;
26885   if (!arg2) {
26886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26887     return ;
26888   }
26889   {
26890     try {
26891       (arg1)->SetGeometry(*arg2);
26892     } catch (std::out_of_range& e) {
26893       {
26894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26895       };
26896     } catch (std::exception& e) {
26897       {
26898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26899       };
26900     } catch (Dali::DaliException e) {
26901       {
26902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26903       };
26904     } catch (...) {
26905       {
26906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26907       };
26908     }
26909   }
26910
26911 }
26912
26913
26914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26915   void * jresult ;
26916   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26917   Dali::Geometry result;
26918
26919   arg1 = (Dali::Renderer *)jarg1;
26920   {
26921     try {
26922       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26923     } catch (std::out_of_range& e) {
26924       {
26925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26926       };
26927     } catch (std::exception& e) {
26928       {
26929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26930       };
26931     } catch (Dali::DaliException e) {
26932       {
26933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26934       };
26935     } catch (...) {
26936       {
26937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26938       };
26939     }
26940   }
26941
26942   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26943   return jresult;
26944 }
26945
26946
26947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26948   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26949   int arg2 ;
26950   int arg3 ;
26951
26952   arg1 = (Dali::Renderer *)jarg1;
26953   arg2 = (int)jarg2;
26954   arg3 = (int)jarg3;
26955   {
26956     try {
26957       (arg1)->SetIndexRange(arg2,arg3);
26958     } catch (std::out_of_range& e) {
26959       {
26960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26961       };
26962     } catch (std::exception& e) {
26963       {
26964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (Dali::DaliException e) {
26967       {
26968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26969       };
26970     } catch (...) {
26971       {
26972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26973       };
26974     }
26975   }
26976
26977 }
26978
26979
26980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26981   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26982   Dali::TextureSet *arg2 = 0 ;
26983
26984   arg1 = (Dali::Renderer *)jarg1;
26985   arg2 = (Dali::TextureSet *)jarg2;
26986   if (!arg2) {
26987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26988     return ;
26989   }
26990   {
26991     try {
26992       (arg1)->SetTextures(*arg2);
26993     } catch (std::out_of_range& e) {
26994       {
26995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26996       };
26997     } catch (std::exception& e) {
26998       {
26999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27000       };
27001     } catch (Dali::DaliException e) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27004       };
27005     } catch (...) {
27006       {
27007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27008       };
27009     }
27010   }
27011
27012 }
27013
27014
27015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27016   void * jresult ;
27017   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27018   Dali::TextureSet result;
27019
27020   arg1 = (Dali::Renderer *)jarg1;
27021   {
27022     try {
27023       result = ((Dali::Renderer const *)arg1)->GetTextures();
27024     } catch (std::out_of_range& e) {
27025       {
27026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (std::exception& e) {
27029       {
27030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (Dali::DaliException e) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042
27043   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27049   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27050   Dali::Shader *arg2 = 0 ;
27051
27052   arg1 = (Dali::Renderer *)jarg1;
27053   arg2 = (Dali::Shader *)jarg2;
27054   if (!arg2) {
27055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27056     return ;
27057   }
27058   {
27059     try {
27060       (arg1)->SetShader(*arg2);
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27076       };
27077     }
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27084   void * jresult ;
27085   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27086   Dali::Shader result;
27087
27088   arg1 = (Dali::Renderer *)jarg1;
27089   {
27090     try {
27091       result = ((Dali::Renderer const *)arg1)->GetShader();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = new Dali::Shader((const Dali::Shader &)result);
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27117   void * jresult ;
27118   Dali::FrameBuffer::Attachment *result = 0 ;
27119
27120   {
27121     try {
27122       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27130       };
27131     } catch (Dali::DaliException e) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27134       };
27135     } catch (...) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27138       };
27139     }
27140   }
27141
27142   jresult = (void *)result;
27143   return jresult;
27144 }
27145
27146
27147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27148   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27149
27150   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27151   {
27152     try {
27153       delete arg1;
27154     } catch (std::out_of_range& e) {
27155       {
27156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27157       };
27158     } catch (std::exception& e) {
27159       {
27160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27161       };
27162     } catch (Dali::DaliException e) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27165       };
27166     } catch (...) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27169       };
27170     }
27171   }
27172
27173 }
27174
27175
27176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27177   void * jresult ;
27178   unsigned int arg1 ;
27179   unsigned int arg2 ;
27180   unsigned int arg3 ;
27181   Dali::FrameBuffer result;
27182
27183   arg1 = (unsigned int)jarg1;
27184   arg2 = (unsigned int)jarg2;
27185   arg3 = (unsigned int)jarg3;
27186   {
27187     try {
27188       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27189     } catch (std::out_of_range& e) {
27190       {
27191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (std::exception& e) {
27194       {
27195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (Dali::DaliException e) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207
27208   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27209   return jresult;
27210 }
27211
27212
27213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27214   void * jresult ;
27215   Dali::FrameBuffer *result = 0 ;
27216
27217   {
27218     try {
27219       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27220     } catch (std::out_of_range& e) {
27221       {
27222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27223       };
27224     } catch (std::exception& e) {
27225       {
27226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27227       };
27228     } catch (Dali::DaliException e) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27231       };
27232     } catch (...) {
27233       {
27234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27235       };
27236     }
27237   }
27238
27239   jresult = (void *)result;
27240   return jresult;
27241 }
27242
27243
27244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27245   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27246
27247   arg1 = (Dali::FrameBuffer *)jarg1;
27248   {
27249     try {
27250       delete arg1;
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27258       };
27259     } catch (Dali::DaliException e) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27262       };
27263     } catch (...) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27266       };
27267     }
27268   }
27269
27270 }
27271
27272
27273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27274   void * jresult ;
27275   Dali::FrameBuffer *arg1 = 0 ;
27276   Dali::FrameBuffer *result = 0 ;
27277
27278   arg1 = (Dali::FrameBuffer *)jarg1;
27279   if (!arg1) {
27280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27281     return 0;
27282   }
27283   {
27284     try {
27285       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27286     } catch (std::out_of_range& e) {
27287       {
27288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27289       };
27290     } catch (std::exception& e) {
27291       {
27292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27293       };
27294     } catch (Dali::DaliException e) {
27295       {
27296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27301       };
27302     }
27303   }
27304
27305   jresult = (void *)result;
27306   return jresult;
27307 }
27308
27309
27310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27311   void * jresult ;
27312   Dali::BaseHandle arg1 ;
27313   Dali::BaseHandle *argp1 ;
27314   Dali::FrameBuffer result;
27315
27316   argp1 = (Dali::BaseHandle *)jarg1;
27317   if (!argp1) {
27318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27319     return 0;
27320   }
27321   arg1 = *argp1;
27322   {
27323     try {
27324       result = Dali::FrameBuffer::DownCast(arg1);
27325     } catch (std::out_of_range& e) {
27326       {
27327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (std::exception& e) {
27330       {
27331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (Dali::DaliException e) {
27334       {
27335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27340       };
27341     }
27342   }
27343
27344   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27345   return jresult;
27346 }
27347
27348
27349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27350   void * jresult ;
27351   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27352   Dali::FrameBuffer *arg2 = 0 ;
27353   Dali::FrameBuffer *result = 0 ;
27354
27355   arg1 = (Dali::FrameBuffer *)jarg1;
27356   arg2 = (Dali::FrameBuffer *)jarg2;
27357   if (!arg2) {
27358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27359     return 0;
27360   }
27361   {
27362     try {
27363       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27364     } catch (std::out_of_range& e) {
27365       {
27366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (std::exception& e) {
27369       {
27370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27371       };
27372     } catch (Dali::DaliException e) {
27373       {
27374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27375       };
27376     } catch (...) {
27377       {
27378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27379       };
27380     }
27381   }
27382
27383   jresult = (void *)result;
27384   return jresult;
27385 }
27386
27387
27388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27389   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27390   Dali::Texture *arg2 = 0 ;
27391
27392   arg1 = (Dali::FrameBuffer *)jarg1;
27393   arg2 = (Dali::Texture *)jarg2;
27394   if (!arg2) {
27395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27396     return ;
27397   }
27398   {
27399     try {
27400       (arg1)->AttachColorTexture(*arg2);
27401     } catch (std::out_of_range& e) {
27402       {
27403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27404       };
27405     } catch (std::exception& e) {
27406       {
27407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27408       };
27409     } catch (Dali::DaliException e) {
27410       {
27411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27412       };
27413     } catch (...) {
27414       {
27415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27416       };
27417     }
27418   }
27419
27420 }
27421
27422
27423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27424   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27425   Dali::Texture *arg2 = 0 ;
27426   unsigned int arg3 ;
27427   unsigned int arg4 ;
27428
27429   arg1 = (Dali::FrameBuffer *)jarg1;
27430   arg2 = (Dali::Texture *)jarg2;
27431   if (!arg2) {
27432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27433     return ;
27434   }
27435   arg3 = (unsigned int)jarg3;
27436   arg4 = (unsigned int)jarg4;
27437   {
27438     try {
27439       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27440     } catch (std::out_of_range& e) {
27441       {
27442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27443       };
27444     } catch (std::exception& e) {
27445       {
27446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27447       };
27448     } catch (Dali::DaliException e) {
27449       {
27450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27451       };
27452     } catch (...) {
27453       {
27454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27455       };
27456     }
27457   }
27458
27459 }
27460
27461
27462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27463   void * jresult ;
27464   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27465   Dali::Texture result;
27466
27467   arg1 = (Dali::FrameBuffer *)jarg1;
27468   {
27469     try {
27470       result = (arg1)->GetColorTexture();
27471     } catch (std::out_of_range& e) {
27472       {
27473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27474       };
27475     } catch (std::exception& e) {
27476       {
27477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27478       };
27479     } catch (Dali::DaliException e) {
27480       {
27481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27482       };
27483     } catch (...) {
27484       {
27485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27486       };
27487     }
27488   }
27489
27490   jresult = new Dali::Texture((const Dali::Texture &)result);
27491   return jresult;
27492 }
27493
27494
27495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27496   void * jresult ;
27497   Dali::RenderTaskList *result = 0 ;
27498
27499   {
27500     try {
27501       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27502     } catch (std::out_of_range& e) {
27503       {
27504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27505       };
27506     } catch (std::exception& e) {
27507       {
27508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27509       };
27510     } catch (Dali::DaliException e) {
27511       {
27512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27513       };
27514     } catch (...) {
27515       {
27516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27517       };
27518     }
27519   }
27520
27521   jresult = (void *)result;
27522   return jresult;
27523 }
27524
27525
27526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27527   void * jresult ;
27528   Dali::BaseHandle arg1 ;
27529   Dali::BaseHandle *argp1 ;
27530   Dali::RenderTaskList result;
27531
27532   argp1 = (Dali::BaseHandle *)jarg1;
27533   if (!argp1) {
27534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27535     return 0;
27536   }
27537   arg1 = *argp1;
27538   {
27539     try {
27540       result = Dali::RenderTaskList::DownCast(arg1);
27541     } catch (std::out_of_range& e) {
27542       {
27543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27544       };
27545     } catch (std::exception& e) {
27546       {
27547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27548       };
27549     } catch (Dali::DaliException e) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27552       };
27553     } catch (...) {
27554       {
27555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27556       };
27557     }
27558   }
27559
27560   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27561   return jresult;
27562 }
27563
27564
27565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27566   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27567
27568   arg1 = (Dali::RenderTaskList *)jarg1;
27569   {
27570     try {
27571       delete arg1;
27572     } catch (std::out_of_range& e) {
27573       {
27574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27575       };
27576     } catch (std::exception& e) {
27577       {
27578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27579       };
27580     } catch (Dali::DaliException e) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27583       };
27584     } catch (...) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27587       };
27588     }
27589   }
27590
27591 }
27592
27593
27594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27595   void * jresult ;
27596   Dali::RenderTaskList *arg1 = 0 ;
27597   Dali::RenderTaskList *result = 0 ;
27598
27599   arg1 = (Dali::RenderTaskList *)jarg1;
27600   if (!arg1) {
27601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27602     return 0;
27603   }
27604   {
27605     try {
27606       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27607     } catch (std::out_of_range& e) {
27608       {
27609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27610       };
27611     } catch (std::exception& e) {
27612       {
27613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27614       };
27615     } catch (Dali::DaliException e) {
27616       {
27617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27618       };
27619     } catch (...) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27622       };
27623     }
27624   }
27625
27626   jresult = (void *)result;
27627   return jresult;
27628 }
27629
27630
27631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27632   void * jresult ;
27633   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27634   Dali::RenderTaskList *arg2 = 0 ;
27635   Dali::RenderTaskList *result = 0 ;
27636
27637   arg1 = (Dali::RenderTaskList *)jarg1;
27638   arg2 = (Dali::RenderTaskList *)jarg2;
27639   if (!arg2) {
27640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27641     return 0;
27642   }
27643   {
27644     try {
27645       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27646     } catch (std::out_of_range& e) {
27647       {
27648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27649       };
27650     } catch (std::exception& e) {
27651       {
27652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27653       };
27654     } catch (Dali::DaliException e) {
27655       {
27656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27657       };
27658     } catch (...) {
27659       {
27660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27661       };
27662     }
27663   }
27664
27665   jresult = (void *)result;
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27671   void * jresult ;
27672   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27673   Dali::RenderTask result;
27674
27675   arg1 = (Dali::RenderTaskList *)jarg1;
27676   {
27677     try {
27678       result = (arg1)->CreateTask();
27679     } catch (std::out_of_range& e) {
27680       {
27681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27682       };
27683     } catch (std::exception& e) {
27684       {
27685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27686       };
27687     } catch (Dali::DaliException e) {
27688       {
27689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27690       };
27691     } catch (...) {
27692       {
27693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27694       };
27695     }
27696   }
27697
27698   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27699   return jresult;
27700 }
27701
27702
27703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27704   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27705   Dali::RenderTask arg2 ;
27706   Dali::RenderTask *argp2 ;
27707
27708   arg1 = (Dali::RenderTaskList *)jarg1;
27709   argp2 = (Dali::RenderTask *)jarg2;
27710   if (!argp2) {
27711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27712     return ;
27713   }
27714   arg2 = *argp2;
27715   {
27716     try {
27717       (arg1)->RemoveTask(arg2);
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27725       };
27726     } catch (Dali::DaliException e) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27729       };
27730     } catch (...) {
27731       {
27732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27733       };
27734     }
27735   }
27736
27737 }
27738
27739
27740 //// ===============================================end part 1 =================
27741
27742 //// ========================= part 2 ===============================
27743
27744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27745   unsigned int jresult ;
27746   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27747   unsigned int result;
27748
27749   arg1 = (Dali::RenderTaskList *)jarg1;
27750   {
27751     try {
27752       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27753     } catch (std::out_of_range& e) {
27754       {
27755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27756       };
27757     } catch (std::exception& e) {
27758       {
27759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (Dali::DaliException e) {
27762       {
27763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27764       };
27765     } catch (...) {
27766       {
27767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27768       };
27769     }
27770   }
27771
27772   jresult = result;
27773   return jresult;
27774 }
27775
27776
27777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27778   void * jresult ;
27779   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27780   unsigned int arg2 ;
27781   Dali::RenderTask result;
27782
27783   arg1 = (Dali::RenderTaskList *)jarg1;
27784   arg2 = (unsigned int)jarg2;
27785   {
27786     try {
27787       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27788     } catch (std::out_of_range& e) {
27789       {
27790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27791       };
27792     } catch (std::exception& e) {
27793       {
27794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27795       };
27796     } catch (Dali::DaliException e) {
27797       {
27798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27799       };
27800     } catch (...) {
27801       {
27802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27803       };
27804     }
27805   }
27806
27807   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27808   return jresult;
27809 }
27810
27811
27812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27813   int jresult ;
27814   int result;
27815
27816   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27817   jresult = (int)result;
27818   return jresult;
27819 }
27820
27821
27822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27823   int jresult ;
27824   int result;
27825
27826   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27827   jresult = (int)result;
27828   return jresult;
27829 }
27830
27831
27832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27833   int jresult ;
27834   int result;
27835
27836   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27837   jresult = (int)result;
27838   return jresult;
27839 }
27840
27841
27842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27843   int jresult ;
27844   int result;
27845
27846   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27847   jresult = (int)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27853   void * jresult ;
27854   Dali::RenderTask::Property *result = 0 ;
27855
27856   {
27857     try {
27858       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27859     } catch (std::out_of_range& e) {
27860       {
27861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27862       };
27863     } catch (std::exception& e) {
27864       {
27865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27866       };
27867     } catch (Dali::DaliException e) {
27868       {
27869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27870       };
27871     } catch (...) {
27872       {
27873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27874       };
27875     }
27876   }
27877
27878   jresult = (void *)result;
27879   return jresult;
27880 }
27881
27882
27883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27884   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27885
27886   arg1 = (Dali::RenderTask::Property *)jarg1;
27887   {
27888     try {
27889       delete arg1;
27890     } catch (std::out_of_range& e) {
27891       {
27892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27893       };
27894     } catch (std::exception& e) {
27895       {
27896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27897       };
27898     } catch (Dali::DaliException e) {
27899       {
27900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27901       };
27902     } catch (...) {
27903       {
27904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27905       };
27906     }
27907   }
27908
27909 }
27910
27911
27912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27913   void * jresult ;
27914   bool (*result)(Dali::Vector2 &) = 0 ;
27915
27916   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27917   jresult = (void *)result;
27918   return jresult;
27919 }
27920
27921
27922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27923   void * jresult ;
27924   bool (*result)(Dali::Vector2 &) = 0 ;
27925
27926   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27927   jresult = (void *)result;
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27933   unsigned int jresult ;
27934   bool result;
27935
27936   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27937   jresult = result;
27938   return jresult;
27939 }
27940
27941
27942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27943   unsigned int jresult ;
27944   bool result;
27945
27946   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27947   jresult = result;
27948   return jresult;
27949 }
27950
27951
27952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27953   void * jresult ;
27954   Dali::Vector4 *result = 0 ;
27955
27956   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27957   jresult = (void *)result;
27958   return jresult;
27959 }
27960
27961
27962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27963   unsigned int jresult ;
27964   bool result;
27965
27966   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27967   jresult = result;
27968   return jresult;
27969 }
27970
27971
27972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27973   unsigned int jresult ;
27974   bool result;
27975
27976   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27977   jresult = result;
27978   return jresult;
27979 }
27980
27981
27982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27983   unsigned int jresult ;
27984   unsigned int result;
27985
27986   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27987   jresult = result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27993   void * jresult ;
27994   Dali::RenderTask *result = 0 ;
27995
27996   {
27997     try {
27998       result = (Dali::RenderTask *)new Dali::RenderTask();
27999     } catch (std::out_of_range& e) {
28000       {
28001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28002       };
28003     } catch (std::exception& e) {
28004       {
28005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28006       };
28007     } catch (Dali::DaliException e) {
28008       {
28009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28010       };
28011     } catch (...) {
28012       {
28013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28014       };
28015     }
28016   }
28017
28018   jresult = (void *)result;
28019   return jresult;
28020 }
28021
28022
28023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28024   void * jresult ;
28025   Dali::BaseHandle arg1 ;
28026   Dali::BaseHandle *argp1 ;
28027   Dali::RenderTask result;
28028
28029   argp1 = (Dali::BaseHandle *)jarg1;
28030   if (!argp1) {
28031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28032     return 0;
28033   }
28034   arg1 = *argp1;
28035   {
28036     try {
28037       result = Dali::RenderTask::DownCast(arg1);
28038     } catch (std::out_of_range& e) {
28039       {
28040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28041       };
28042     } catch (std::exception& e) {
28043       {
28044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28045       };
28046     } catch (Dali::DaliException e) {
28047       {
28048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28049       };
28050     } catch (...) {
28051       {
28052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28053       };
28054     }
28055   }
28056
28057   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28058   return jresult;
28059 }
28060
28061
28062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28063   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28064
28065   arg1 = (Dali::RenderTask *)jarg1;
28066   {
28067     try {
28068       delete arg1;
28069     } catch (std::out_of_range& e) {
28070       {
28071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28072       };
28073     } catch (std::exception& e) {
28074       {
28075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28076       };
28077     } catch (Dali::DaliException e) {
28078       {
28079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28080       };
28081     } catch (...) {
28082       {
28083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28084       };
28085     }
28086   }
28087
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28092   void * jresult ;
28093   Dali::RenderTask *arg1 = 0 ;
28094   Dali::RenderTask *result = 0 ;
28095
28096   arg1 = (Dali::RenderTask *)jarg1;
28097   if (!arg1) {
28098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28099     return 0;
28100   }
28101   {
28102     try {
28103       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28104     } catch (std::out_of_range& e) {
28105       {
28106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28107       };
28108     } catch (std::exception& e) {
28109       {
28110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28111       };
28112     } catch (Dali::DaliException e) {
28113       {
28114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28115       };
28116     } catch (...) {
28117       {
28118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28119       };
28120     }
28121   }
28122
28123   jresult = (void *)result;
28124   return jresult;
28125 }
28126
28127
28128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28129   void * jresult ;
28130   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28131   Dali::RenderTask *arg2 = 0 ;
28132   Dali::RenderTask *result = 0 ;
28133
28134   arg1 = (Dali::RenderTask *)jarg1;
28135   arg2 = (Dali::RenderTask *)jarg2;
28136   if (!arg2) {
28137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28138     return 0;
28139   }
28140   {
28141     try {
28142       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28143     } catch (std::out_of_range& e) {
28144       {
28145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28146       };
28147     } catch (std::exception& e) {
28148       {
28149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28150       };
28151     } catch (Dali::DaliException e) {
28152       {
28153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28154       };
28155     } catch (...) {
28156       {
28157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28158       };
28159     }
28160   }
28161
28162   jresult = (void *)result;
28163   return jresult;
28164 }
28165
28166
28167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28168   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28169   Dali::Actor arg2 ;
28170   Dali::Actor *argp2 ;
28171
28172   arg1 = (Dali::RenderTask *)jarg1;
28173   argp2 = (Dali::Actor *)jarg2;
28174   if (!argp2) {
28175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28176     return ;
28177   }
28178   arg2 = *argp2;
28179   {
28180     try {
28181       (arg1)->SetSourceActor(arg2);
28182     } catch (std::out_of_range& e) {
28183       {
28184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28185       };
28186     } catch (std::exception& e) {
28187       {
28188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28189       };
28190     } catch (Dali::DaliException e) {
28191       {
28192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28193       };
28194     } catch (...) {
28195       {
28196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28197       };
28198     }
28199   }
28200
28201 }
28202
28203
28204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28205   void * jresult ;
28206   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28207   Dali::Actor result;
28208
28209   arg1 = (Dali::RenderTask *)jarg1;
28210   {
28211     try {
28212       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28220       };
28221     } catch (Dali::DaliException e) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28224       };
28225     } catch (...) {
28226       {
28227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28228       };
28229     }
28230   }
28231
28232   jresult = new Dali::Actor((const Dali::Actor &)result);
28233   return jresult;
28234 }
28235
28236
28237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28238   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28239   bool arg2 ;
28240
28241   arg1 = (Dali::RenderTask *)jarg1;
28242   arg2 = jarg2 ? true : false;
28243   {
28244     try {
28245       (arg1)->SetExclusive(arg2);
28246     } catch (std::out_of_range& e) {
28247       {
28248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28249       };
28250     } catch (std::exception& e) {
28251       {
28252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28253       };
28254     } catch (Dali::DaliException e) {
28255       {
28256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28257       };
28258     } catch (...) {
28259       {
28260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28261       };
28262     }
28263   }
28264
28265 }
28266
28267
28268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28269   unsigned int jresult ;
28270   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28271   bool result;
28272
28273   arg1 = (Dali::RenderTask *)jarg1;
28274   {
28275     try {
28276       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28277     } catch (std::out_of_range& e) {
28278       {
28279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28280       };
28281     } catch (std::exception& e) {
28282       {
28283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28284       };
28285     } catch (Dali::DaliException e) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28288       };
28289     } catch (...) {
28290       {
28291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28292       };
28293     }
28294   }
28295
28296   jresult = result;
28297   return jresult;
28298 }
28299
28300
28301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28302   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28303   bool arg2 ;
28304
28305   arg1 = (Dali::RenderTask *)jarg1;
28306   arg2 = jarg2 ? true : false;
28307   {
28308     try {
28309       (arg1)->SetInputEnabled(arg2);
28310     } catch (std::out_of_range& e) {
28311       {
28312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28313       };
28314     } catch (std::exception& e) {
28315       {
28316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28317       };
28318     } catch (Dali::DaliException e) {
28319       {
28320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28321       };
28322     } catch (...) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28325       };
28326     }
28327   }
28328
28329 }
28330
28331
28332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28333   unsigned int jresult ;
28334   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28335   bool result;
28336
28337   arg1 = (Dali::RenderTask *)jarg1;
28338   {
28339     try {
28340       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28341     } catch (std::out_of_range& e) {
28342       {
28343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28344       };
28345     } catch (std::exception& e) {
28346       {
28347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28348       };
28349     } catch (Dali::DaliException e) {
28350       {
28351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28352       };
28353     } catch (...) {
28354       {
28355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28356       };
28357     }
28358   }
28359
28360   jresult = result;
28361   return jresult;
28362 }
28363
28364
28365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28366   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28367   Dali::CameraActor arg2 ;
28368   Dali::CameraActor *argp2 ;
28369
28370   arg1 = (Dali::RenderTask *)jarg1;
28371   argp2 = (Dali::CameraActor *)jarg2;
28372   if (!argp2) {
28373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28374     return ;
28375   }
28376   arg2 = *argp2;
28377   {
28378     try {
28379       (arg1)->SetCameraActor(arg2);
28380     } catch (std::out_of_range& e) {
28381       {
28382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28383       };
28384     } catch (std::exception& e) {
28385       {
28386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28387       };
28388     } catch (Dali::DaliException e) {
28389       {
28390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28391       };
28392     } catch (...) {
28393       {
28394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28395       };
28396     }
28397   }
28398
28399 }
28400
28401
28402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28403   void * jresult ;
28404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28405   Dali::CameraActor result;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   {
28409     try {
28410       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28411     } catch (std::out_of_range& e) {
28412       {
28413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28414       };
28415     } catch (std::exception& e) {
28416       {
28417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28418       };
28419     } catch (Dali::DaliException e) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28422       };
28423     } catch (...) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28426       };
28427     }
28428   }
28429
28430   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28431   return jresult;
28432 }
28433
28434
28435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28436   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28437   Dali::FrameBuffer arg2 ;
28438   Dali::FrameBuffer *argp2 ;
28439
28440   arg1 = (Dali::RenderTask *)jarg1;
28441   argp2 = (Dali::FrameBuffer *)jarg2;
28442   if (!argp2) {
28443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28444     return ;
28445   }
28446   arg2 = *argp2;
28447   {
28448     try {
28449       (arg1)->SetFrameBuffer(arg2);
28450     } catch (std::out_of_range& e) {
28451       {
28452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28453       };
28454     } catch (std::exception& e) {
28455       {
28456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28457       };
28458     } catch (Dali::DaliException e) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28461       };
28462     } catch (...) {
28463       {
28464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28465       };
28466     }
28467   }
28468
28469 }
28470
28471
28472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28473   void * jresult ;
28474   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28475   Dali::FrameBuffer result;
28476
28477   arg1 = (Dali::RenderTask *)jarg1;
28478   {
28479     try {
28480       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28481     } catch (std::out_of_range& e) {
28482       {
28483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28484       };
28485     } catch (std::exception& e) {
28486       {
28487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28488       };
28489     } catch (Dali::DaliException e) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28496       };
28497     }
28498   }
28499
28500   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28501   return jresult;
28502 }
28503
28504
28505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28506   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28507   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28508
28509   arg1 = (Dali::RenderTask *)jarg1;
28510   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28511   {
28512     try {
28513       (arg1)->SetScreenToFrameBufferFunction(arg2);
28514     } catch (std::out_of_range& e) {
28515       {
28516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28517       };
28518     } catch (std::exception& e) {
28519       {
28520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28521       };
28522     } catch (Dali::DaliException e) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28525       };
28526     } catch (...) {
28527       {
28528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28529       };
28530     }
28531   }
28532
28533 }
28534
28535
28536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28537   void * jresult ;
28538   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28539   Dali::RenderTask::ScreenToFrameBufferFunction result;
28540
28541   arg1 = (Dali::RenderTask *)jarg1;
28542   {
28543     try {
28544       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28545     } catch (std::out_of_range& e) {
28546       {
28547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28548       };
28549     } catch (std::exception& e) {
28550       {
28551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28552       };
28553     } catch (Dali::DaliException e) {
28554       {
28555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28556       };
28557     } catch (...) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28560       };
28561     }
28562   }
28563
28564   jresult = (void *)result;
28565   return jresult;
28566 }
28567
28568
28569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28570   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28571   Dali::Actor arg2 ;
28572   Dali::Actor *argp2 ;
28573
28574   arg1 = (Dali::RenderTask *)jarg1;
28575   argp2 = (Dali::Actor *)jarg2;
28576   if (!argp2) {
28577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28578     return ;
28579   }
28580   arg2 = *argp2;
28581   {
28582     try {
28583       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28584     } catch (std::out_of_range& e) {
28585       {
28586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28587       };
28588     } catch (std::exception& e) {
28589       {
28590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28591       };
28592     } catch (Dali::DaliException e) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28595       };
28596     } catch (...) {
28597       {
28598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28599       };
28600     }
28601   }
28602
28603 }
28604
28605
28606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28607   void * jresult ;
28608   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28609   Dali::Actor result;
28610
28611   arg1 = (Dali::RenderTask *)jarg1;
28612   {
28613     try {
28614       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28615     } catch (std::out_of_range& e) {
28616       {
28617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28618       };
28619     } catch (std::exception& e) {
28620       {
28621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28622       };
28623     } catch (Dali::DaliException e) {
28624       {
28625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28626       };
28627     } catch (...) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28630       };
28631     }
28632   }
28633
28634   jresult = new Dali::Actor((const Dali::Actor &)result);
28635   return jresult;
28636 }
28637
28638
28639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28640   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28641   Dali::Vector2 arg2 ;
28642   Dali::Vector2 *argp2 ;
28643
28644   arg1 = (Dali::RenderTask *)jarg1;
28645   argp2 = (Dali::Vector2 *)jarg2;
28646   if (!argp2) {
28647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28648     return ;
28649   }
28650   arg2 = *argp2;
28651   {
28652     try {
28653       (arg1)->SetViewportPosition(arg2);
28654     } catch (std::out_of_range& e) {
28655       {
28656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28657       };
28658     } catch (std::exception& e) {
28659       {
28660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28661       };
28662     } catch (Dali::DaliException e) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28665       };
28666     } catch (...) {
28667       {
28668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28669       };
28670     }
28671   }
28672
28673 }
28674
28675
28676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28677   void * jresult ;
28678   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28679   Dali::Vector2 result;
28680
28681   arg1 = (Dali::RenderTask *)jarg1;
28682   {
28683     try {
28684       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28685     } catch (std::out_of_range& e) {
28686       {
28687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28688       };
28689     } catch (std::exception& e) {
28690       {
28691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28692       };
28693     } catch (Dali::DaliException e) {
28694       {
28695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28696       };
28697     } catch (...) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28700       };
28701     }
28702   }
28703
28704   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28705   return jresult;
28706 }
28707
28708
28709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28710   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28711   Dali::Vector2 arg2 ;
28712   Dali::Vector2 *argp2 ;
28713
28714   arg1 = (Dali::RenderTask *)jarg1;
28715   argp2 = (Dali::Vector2 *)jarg2;
28716   if (!argp2) {
28717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28718     return ;
28719   }
28720   arg2 = *argp2;
28721   {
28722     try {
28723       (arg1)->SetViewportSize(arg2);
28724     } catch (std::out_of_range& e) {
28725       {
28726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28727       };
28728     } catch (std::exception& e) {
28729       {
28730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28731       };
28732     } catch (Dali::DaliException e) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28735       };
28736     } catch (...) {
28737       {
28738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28739       };
28740     }
28741   }
28742
28743 }
28744
28745
28746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28747   void * jresult ;
28748   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28749   Dali::Vector2 result;
28750
28751   arg1 = (Dali::RenderTask *)jarg1;
28752   {
28753     try {
28754       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28755     } catch (std::out_of_range& e) {
28756       {
28757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28758       };
28759     } catch (std::exception& e) {
28760       {
28761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28762       };
28763     } catch (Dali::DaliException e) {
28764       {
28765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28766       };
28767     } catch (...) {
28768       {
28769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28770       };
28771     }
28772   }
28773
28774   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28775   return jresult;
28776 }
28777
28778
28779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28780   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28781   Dali::Viewport arg2 ;
28782   Dali::Viewport *argp2 ;
28783
28784   arg1 = (Dali::RenderTask *)jarg1;
28785   argp2 = (Dali::Viewport *)jarg2;
28786   if (!argp2) {
28787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28788     return ;
28789   }
28790   arg2 = *argp2;
28791   {
28792     try {
28793       (arg1)->SetViewport(arg2);
28794     } catch (std::out_of_range& e) {
28795       {
28796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28797       };
28798     } catch (std::exception& e) {
28799       {
28800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28801       };
28802     } catch (Dali::DaliException e) {
28803       {
28804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28805       };
28806     } catch (...) {
28807       {
28808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28809       };
28810     }
28811   }
28812
28813 }
28814
28815
28816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28817   void * jresult ;
28818   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28819   Dali::Viewport result;
28820
28821   arg1 = (Dali::RenderTask *)jarg1;
28822   {
28823     try {
28824       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28825     } catch (std::out_of_range& e) {
28826       {
28827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28828       };
28829     } catch (std::exception& e) {
28830       {
28831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28832       };
28833     } catch (Dali::DaliException e) {
28834       {
28835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28836       };
28837     } catch (...) {
28838       {
28839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28840       };
28841     }
28842   }
28843
28844   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28845   return jresult;
28846 }
28847
28848
28849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28850   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28851   Dali::Vector4 *arg2 = 0 ;
28852
28853   arg1 = (Dali::RenderTask *)jarg1;
28854   arg2 = (Dali::Vector4 *)jarg2;
28855   if (!arg2) {
28856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28857     return ;
28858   }
28859   {
28860     try {
28861       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28862     } catch (std::out_of_range& e) {
28863       {
28864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28865       };
28866     } catch (std::exception& e) {
28867       {
28868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28869       };
28870     } catch (Dali::DaliException e) {
28871       {
28872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28873       };
28874     } catch (...) {
28875       {
28876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28877       };
28878     }
28879   }
28880
28881 }
28882
28883
28884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28885   void * jresult ;
28886   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28887   Dali::Vector4 result;
28888
28889   arg1 = (Dali::RenderTask *)jarg1;
28890   {
28891     try {
28892       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28908       };
28909     }
28910   }
28911
28912   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28913   return jresult;
28914 }
28915
28916
28917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28918   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28919   bool arg2 ;
28920
28921   arg1 = (Dali::RenderTask *)jarg1;
28922   arg2 = jarg2 ? true : false;
28923   {
28924     try {
28925       (arg1)->SetClearEnabled(arg2);
28926     } catch (std::out_of_range& e) {
28927       {
28928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28929       };
28930     } catch (std::exception& e) {
28931       {
28932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28933       };
28934     } catch (Dali::DaliException e) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28937       };
28938     } catch (...) {
28939       {
28940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28941       };
28942     }
28943   }
28944
28945 }
28946
28947
28948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28949   unsigned int jresult ;
28950   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28951   bool result;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   {
28955     try {
28956       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28957     } catch (std::out_of_range& e) {
28958       {
28959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28960       };
28961     } catch (std::exception& e) {
28962       {
28963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28964       };
28965     } catch (Dali::DaliException e) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28968       };
28969     } catch (...) {
28970       {
28971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28972       };
28973     }
28974   }
28975
28976   jresult = result;
28977   return jresult;
28978 }
28979
28980
28981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28983   bool arg2 ;
28984
28985   arg1 = (Dali::RenderTask *)jarg1;
28986   arg2 = jarg2 ? true : false;
28987   {
28988     try {
28989       (arg1)->SetCullMode(arg2);
28990     } catch (std::out_of_range& e) {
28991       {
28992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28993       };
28994     } catch (std::exception& e) {
28995       {
28996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28997       };
28998     } catch (Dali::DaliException e) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29001       };
29002     } catch (...) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29005       };
29006     }
29007   }
29008
29009 }
29010
29011
29012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29013   unsigned int jresult ;
29014   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29015   bool result;
29016
29017   arg1 = (Dali::RenderTask *)jarg1;
29018   {
29019     try {
29020       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29021     } catch (std::out_of_range& e) {
29022       {
29023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29024       };
29025     } catch (std::exception& e) {
29026       {
29027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29028       };
29029     } catch (Dali::DaliException e) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29032       };
29033     } catch (...) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29036       };
29037     }
29038   }
29039
29040   jresult = result;
29041   return jresult;
29042 }
29043
29044
29045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29046   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29047   unsigned int arg2 ;
29048
29049   arg1 = (Dali::RenderTask *)jarg1;
29050   arg2 = (unsigned int)jarg2;
29051   {
29052     try {
29053       (arg1)->SetRefreshRate(arg2);
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29061       };
29062     } catch (Dali::DaliException e) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29065       };
29066     } catch (...) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29069       };
29070     }
29071   }
29072
29073 }
29074
29075
29076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29077   unsigned int jresult ;
29078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29079   unsigned int result;
29080
29081   arg1 = (Dali::RenderTask *)jarg1;
29082   {
29083     try {
29084       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29085     } catch (std::out_of_range& e) {
29086       {
29087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29088       };
29089     } catch (std::exception& e) {
29090       {
29091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29092       };
29093     } catch (Dali::DaliException e) {
29094       {
29095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29096       };
29097     } catch (...) {
29098       {
29099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29100       };
29101     }
29102   }
29103
29104   jresult = result;
29105   return jresult;
29106 }
29107
29108
29109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29110   unsigned int jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Vector3 *arg2 = 0 ;
29113   float *arg3 = 0 ;
29114   float *arg4 = 0 ;
29115   bool result;
29116
29117   arg1 = (Dali::RenderTask *)jarg1;
29118   arg2 = (Dali::Vector3 *)jarg2;
29119   if (!arg2) {
29120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29121     return 0;
29122   }
29123   arg3 = (float *)jarg3;
29124   arg4 = (float *)jarg4;
29125   {
29126     try {
29127       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29128     } catch (std::out_of_range& e) {
29129       {
29130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (std::exception& e) {
29133       {
29134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (Dali::DaliException e) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29139       };
29140     } catch (...) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29143       };
29144     }
29145   }
29146
29147   jresult = result;
29148   return jresult;
29149 }
29150
29151
29152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29153   unsigned int jresult ;
29154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29155   Dali::Actor arg2 ;
29156   float arg3 ;
29157   float arg4 ;
29158   float *arg5 = 0 ;
29159   float *arg6 = 0 ;
29160   Dali::Actor *argp2 ;
29161   bool result;
29162
29163   arg1 = (Dali::RenderTask *)jarg1;
29164   argp2 = (Dali::Actor *)jarg2;
29165   if (!argp2) {
29166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29167     return 0;
29168   }
29169   arg2 = *argp2;
29170   arg3 = (float)jarg3;
29171   arg4 = (float)jarg4;
29172   arg5 = (float *)jarg5;
29173   arg6 = (float *)jarg6;
29174   {
29175     try {
29176       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29177     } catch (std::out_of_range& e) {
29178       {
29179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29180       };
29181     } catch (std::exception& e) {
29182       {
29183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29184       };
29185     } catch (Dali::DaliException e) {
29186       {
29187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29188       };
29189     } catch (...) {
29190       {
29191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29192       };
29193     }
29194   }
29195
29196   jresult = result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29202   void * jresult ;
29203   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29204   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29205
29206   arg1 = (Dali::RenderTask *)jarg1;
29207   {
29208     try {
29209       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29210     } catch (std::out_of_range& e) {
29211       {
29212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29213       };
29214     } catch (std::exception& e) {
29215       {
29216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29217       };
29218     } catch (Dali::DaliException e) {
29219       {
29220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29221       };
29222     } catch (...) {
29223       {
29224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29225       };
29226     }
29227   }
29228
29229   jresult = (void *)result;
29230   return jresult;
29231 }
29232
29233
29234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29235   void * jresult ;
29236   int arg1 ;
29237   Dali::TouchPoint::State arg2 ;
29238   float arg3 ;
29239   float arg4 ;
29240   Dali::TouchPoint *result = 0 ;
29241
29242   arg1 = (int)jarg1;
29243   arg2 = (Dali::TouchPoint::State)jarg2;
29244   arg3 = (float)jarg3;
29245   arg4 = (float)jarg4;
29246   {
29247     try {
29248       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29249     } catch (std::out_of_range& e) {
29250       {
29251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29252       };
29253     } catch (std::exception& e) {
29254       {
29255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29256       };
29257     } catch (Dali::DaliException e) {
29258       {
29259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29260       };
29261     } catch (...) {
29262       {
29263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29264       };
29265     }
29266   }
29267
29268   jresult = (void *)result;
29269   return jresult;
29270 }
29271
29272
29273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29274   void * jresult ;
29275   int arg1 ;
29276   Dali::TouchPoint::State arg2 ;
29277   float arg3 ;
29278   float arg4 ;
29279   float arg5 ;
29280   float arg6 ;
29281   Dali::TouchPoint *result = 0 ;
29282
29283   arg1 = (int)jarg1;
29284   arg2 = (Dali::TouchPoint::State)jarg2;
29285   arg3 = (float)jarg3;
29286   arg4 = (float)jarg4;
29287   arg5 = (float)jarg5;
29288   arg6 = (float)jarg6;
29289   {
29290     try {
29291       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29292     } catch (std::out_of_range& e) {
29293       {
29294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29295       };
29296     } catch (std::exception& e) {
29297       {
29298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29299       };
29300     } catch (Dali::DaliException e) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29303       };
29304     } catch (...) {
29305       {
29306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29307       };
29308     }
29309   }
29310
29311   jresult = (void *)result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29317   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29318
29319   arg1 = (Dali::TouchPoint *)jarg1;
29320   {
29321     try {
29322       delete arg1;
29323     } catch (std::out_of_range& e) {
29324       {
29325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29326       };
29327     } catch (std::exception& e) {
29328       {
29329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29330       };
29331     } catch (Dali::DaliException e) {
29332       {
29333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29334       };
29335     } catch (...) {
29336       {
29337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29338       };
29339     }
29340   }
29341
29342 }
29343
29344
29345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29346   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29347   int arg2 ;
29348
29349   arg1 = (Dali::TouchPoint *)jarg1;
29350   arg2 = (int)jarg2;
29351   if (arg1) (arg1)->deviceId = arg2;
29352 }
29353
29354
29355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29356   int jresult ;
29357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29358   int result;
29359
29360   arg1 = (Dali::TouchPoint *)jarg1;
29361   result = (int) ((arg1)->deviceId);
29362   jresult = result;
29363   return jresult;
29364 }
29365
29366
29367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29369   Dali::TouchPoint::State arg2 ;
29370
29371   arg1 = (Dali::TouchPoint *)jarg1;
29372   arg2 = (Dali::TouchPoint::State)jarg2;
29373   if (arg1) (arg1)->state = arg2;
29374 }
29375
29376
29377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29378   int jresult ;
29379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29380   Dali::TouchPoint::State result;
29381
29382   arg1 = (Dali::TouchPoint *)jarg1;
29383   result = (Dali::TouchPoint::State) ((arg1)->state);
29384   jresult = (int)result;
29385   return jresult;
29386 }
29387
29388
29389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29391   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29392
29393   arg1 = (Dali::TouchPoint *)jarg1;
29394   arg2 = (Dali::Actor *)jarg2;
29395   if (arg1) (arg1)->hitActor = *arg2;
29396 }
29397
29398
29399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29400   void * jresult ;
29401   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29402   Dali::Actor *result = 0 ;
29403
29404   arg1 = (Dali::TouchPoint *)jarg1;
29405   result = (Dali::Actor *)& ((arg1)->hitActor);
29406   jresult = (void *)result;
29407   return jresult;
29408 }
29409
29410
29411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29412   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29413   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29414
29415   arg1 = (Dali::TouchPoint *)jarg1;
29416   arg2 = (Dali::Vector2 *)jarg2;
29417   if (arg1) (arg1)->local = *arg2;
29418 }
29419
29420
29421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29422   void * jresult ;
29423   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29424   Dali::Vector2 *result = 0 ;
29425
29426   arg1 = (Dali::TouchPoint *)jarg1;
29427   result = (Dali::Vector2 *)& ((arg1)->local);
29428   jresult = (void *)result;
29429   return jresult;
29430 }
29431
29432
29433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29434   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29435   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29436
29437   arg1 = (Dali::TouchPoint *)jarg1;
29438   arg2 = (Dali::Vector2 *)jarg2;
29439   if (arg1) (arg1)->screen = *arg2;
29440 }
29441
29442
29443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29444   void * jresult ;
29445   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29446   Dali::Vector2 *result = 0 ;
29447
29448   arg1 = (Dali::TouchPoint *)jarg1;
29449   result = (Dali::Vector2 *)& ((arg1)->screen);
29450   jresult = (void *)result;
29451   return jresult;
29452 }
29453
29454
29455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29456   void * jresult ;
29457   Dali::TouchData *result = 0 ;
29458
29459   {
29460     try {
29461       result = (Dali::TouchData *)new Dali::TouchData();
29462     } catch (std::out_of_range& e) {
29463       {
29464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29465       };
29466     } catch (std::exception& e) {
29467       {
29468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (Dali::DaliException e) {
29471       {
29472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29473       };
29474     } catch (...) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29477       };
29478     }
29479   }
29480
29481   jresult = (void *)result;
29482   return jresult;
29483 }
29484
29485
29486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29487   void * jresult ;
29488   Dali::TouchData *arg1 = 0 ;
29489   Dali::TouchData *result = 0 ;
29490
29491   arg1 = (Dali::TouchData *)jarg1;
29492   if (!arg1) {
29493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29494     return 0;
29495   }
29496   {
29497     try {
29498       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29499     } catch (std::out_of_range& e) {
29500       {
29501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29502       };
29503     } catch (std::exception& e) {
29504       {
29505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (Dali::DaliException e) {
29508       {
29509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29510       };
29511     } catch (...) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29514       };
29515     }
29516   }
29517
29518   jresult = (void *)result;
29519   return jresult;
29520 }
29521
29522
29523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29524   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29525
29526   arg1 = (Dali::TouchData *)jarg1;
29527   {
29528     try {
29529       delete arg1;
29530     } catch (std::out_of_range& e) {
29531       {
29532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29533       };
29534     } catch (std::exception& e) {
29535       {
29536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29537       };
29538     } catch (Dali::DaliException e) {
29539       {
29540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29545       };
29546     }
29547   }
29548
29549 }
29550
29551
29552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29553   void * jresult ;
29554   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29555   Dali::TouchData *arg2 = 0 ;
29556   Dali::TouchData *result = 0 ;
29557
29558   arg1 = (Dali::TouchData *)jarg1;
29559   arg2 = (Dali::TouchData *)jarg2;
29560   if (!arg2) {
29561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29562     return 0;
29563   }
29564   {
29565     try {
29566       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29567     } catch (std::out_of_range& e) {
29568       {
29569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29570       };
29571     } catch (std::exception& e) {
29572       {
29573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29574       };
29575     } catch (Dali::DaliException e) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29578       };
29579     } catch (...) {
29580       {
29581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29582       };
29583     }
29584   }
29585
29586   jresult = (void *)result;
29587   return jresult;
29588 }
29589
29590
29591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29592   unsigned long jresult ;
29593   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29594   unsigned long result;
29595
29596   arg1 = (Dali::TouchData *)jarg1;
29597   {
29598     try {
29599       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29600     } catch (std::out_of_range& e) {
29601       {
29602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29603       };
29604     } catch (std::exception& e) {
29605       {
29606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (Dali::DaliException e) {
29609       {
29610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29611       };
29612     } catch (...) {
29613       {
29614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29615       };
29616     }
29617   }
29618
29619   jresult = (unsigned long)result;
29620   return jresult;
29621 }
29622
29623
29624 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29625   unsigned long jresult ;
29626   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29627   std::size_t result;
29628
29629   arg1 = (Dali::TouchData *)jarg1;
29630   {
29631     try {
29632       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29633     } catch (std::out_of_range& e) {
29634       {
29635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (std::exception& e) {
29638       {
29639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (Dali::DaliException e) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29644       };
29645     } catch (...) {
29646       {
29647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29648       };
29649     }
29650   }
29651
29652   jresult = (unsigned long)result;
29653   return jresult;
29654 }
29655
29656
29657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29658   int jresult ;
29659   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29660   std::size_t arg2 ;
29661   int32_t result;
29662
29663   arg1 = (Dali::TouchData *)jarg1;
29664   arg2 = (std::size_t)jarg2;
29665   {
29666     try {
29667       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29668     } catch (std::out_of_range& e) {
29669       {
29670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29671       };
29672     } catch (std::exception& e) {
29673       {
29674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29675       };
29676     } catch (Dali::DaliException e) {
29677       {
29678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29679       };
29680     } catch (...) {
29681       {
29682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29683       };
29684     }
29685   }
29686
29687   jresult = result;
29688   return jresult;
29689 }
29690
29691
29692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29693   int jresult ;
29694   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29695   std::size_t arg2 ;
29696   Dali::PointState::Type result;
29697
29698   arg1 = (Dali::TouchData *)jarg1;
29699   arg2 = (std::size_t)jarg2;
29700   {
29701     try {
29702       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29703     } catch (std::out_of_range& e) {
29704       {
29705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29706       };
29707     } catch (std::exception& e) {
29708       {
29709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (Dali::DaliException e) {
29712       {
29713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29714       };
29715     } catch (...) {
29716       {
29717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29718       };
29719     }
29720   }
29721
29722   jresult = (int)result;
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29728   void * jresult ;
29729   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29730   std::size_t arg2 ;
29731   Dali::Actor result;
29732
29733   arg1 = (Dali::TouchData *)jarg1;
29734   arg2 = (std::size_t)jarg2;
29735   {
29736     try {
29737       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = new Dali::Actor((const Dali::Actor &)result);
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29763   void * jresult ;
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765   std::size_t arg2 ;
29766   Dali::Vector2 *result = 0 ;
29767
29768   arg1 = (Dali::TouchData *)jarg1;
29769   arg2 = (std::size_t)jarg2;
29770   {
29771     try {
29772       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29773     } catch (std::out_of_range& e) {
29774       {
29775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29776       };
29777     } catch (std::exception& e) {
29778       {
29779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29780       };
29781     } catch (Dali::DaliException e) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29784       };
29785     } catch (...) {
29786       {
29787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29788       };
29789     }
29790   }
29791
29792   jresult = (void *)result;
29793   return jresult;
29794 }
29795
29796
29797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29798   void * jresult ;
29799   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29800   std::size_t arg2 ;
29801   Dali::Vector2 *result = 0 ;
29802
29803   arg1 = (Dali::TouchData *)jarg1;
29804   arg2 = (std::size_t)jarg2;
29805   {
29806     try {
29807       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29808     } catch (std::out_of_range& e) {
29809       {
29810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29811       };
29812     } catch (std::exception& e) {
29813       {
29814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (Dali::DaliException e) {
29817       {
29818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29823       };
29824     }
29825   }
29826
29827   jresult = (void *)result;
29828   return jresult;
29829 }
29830
29831
29832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29833   float jresult ;
29834   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29835   std::size_t arg2 ;
29836   float result;
29837
29838   arg1 = (Dali::TouchData *)jarg1;
29839   arg2 = (std::size_t)jarg2;
29840   {
29841     try {
29842       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29843     } catch (std::out_of_range& e) {
29844       {
29845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (std::exception& e) {
29848       {
29849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (Dali::DaliException e) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861
29862   jresult = result;
29863   return jresult;
29864 }
29865
29866
29867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29868   void * jresult ;
29869   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29870   std::size_t arg2 ;
29871   Dali::Vector2 *result = 0 ;
29872
29873   arg1 = (Dali::TouchData *)jarg1;
29874   arg2 = (std::size_t)jarg2;
29875   {
29876     try {
29877       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29878     } catch (std::out_of_range& e) {
29879       {
29880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (std::exception& e) {
29883       {
29884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29885       };
29886     } catch (Dali::DaliException e) {
29887       {
29888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29889       };
29890     } catch (...) {
29891       {
29892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29893       };
29894     }
29895   }
29896
29897   jresult = (void *)result;
29898   return jresult;
29899 }
29900
29901
29902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29903   float jresult ;
29904   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29905   std::size_t arg2 ;
29906   float result;
29907
29908   arg1 = (Dali::TouchData *)jarg1;
29909   arg2 = (std::size_t)jarg2;
29910   {
29911     try {
29912       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29913     } catch (std::out_of_range& e) {
29914       {
29915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (std::exception& e) {
29918       {
29919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (Dali::DaliException e) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29924       };
29925     } catch (...) {
29926       {
29927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29928       };
29929     }
29930   }
29931
29932   jresult = result;
29933   return jresult;
29934 }
29935
29936
29937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29938   void * jresult ;
29939   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29940   std::size_t arg2 ;
29941   Dali::Degree result;
29942
29943   arg1 = (Dali::TouchData *)jarg1;
29944   arg2 = (std::size_t)jarg2;
29945   {
29946     try {
29947       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29948     } catch (std::out_of_range& e) {
29949       {
29950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29951       };
29952     } catch (std::exception& e) {
29953       {
29954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29955       };
29956     } catch (Dali::DaliException e) {
29957       {
29958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29959       };
29960     } catch (...) {
29961       {
29962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29963       };
29964     }
29965   }
29966
29967   jresult = new Dali::Degree((const Dali::Degree &)result);
29968   return jresult;
29969 }
29970
29971
29972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29973   int jresult ;
29974   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29975   std::size_t arg2 ;
29976   Dali::MouseButton::Type result;
29977
29978   arg1 = (Dali::TouchData *)jarg1;
29979   arg2 = (std::size_t)jarg2;
29980   {
29981     try {
29982       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29983     } catch (std::out_of_range& e) {
29984       {
29985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29986       };
29987     } catch (std::exception& e) {
29988       {
29989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29990       };
29991     } catch (Dali::DaliException e) {
29992       {
29993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29994       };
29995     } catch (...) {
29996       {
29997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29998       };
29999     }
30000   }
30001
30002   jresult = static_cast< int >(result);
30003   return jresult;
30004 }
30005
30006
30007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30008   void * jresult ;
30009   Dali::GestureDetector *result = 0 ;
30010
30011   {
30012     try {
30013       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30014     } catch (std::out_of_range& e) {
30015       {
30016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30017       };
30018     } catch (std::exception& e) {
30019       {
30020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30021       };
30022     } catch (Dali::DaliException e) {
30023       {
30024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30025       };
30026     } catch (...) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30029       };
30030     }
30031   }
30032
30033   jresult = (void *)result;
30034   return jresult;
30035 }
30036
30037
30038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30039   void * jresult ;
30040   Dali::BaseHandle arg1 ;
30041   Dali::BaseHandle *argp1 ;
30042   Dali::GestureDetector result;
30043
30044   argp1 = (Dali::BaseHandle *)jarg1;
30045   if (!argp1) {
30046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30047     return 0;
30048   }
30049   arg1 = *argp1;
30050   {
30051     try {
30052       result = Dali::GestureDetector::DownCast(arg1);
30053     } catch (std::out_of_range& e) {
30054       {
30055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30056       };
30057     } catch (std::exception& e) {
30058       {
30059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30060       };
30061     } catch (Dali::DaliException e) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30064       };
30065     } catch (...) {
30066       {
30067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30068       };
30069     }
30070   }
30071
30072   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30073   return jresult;
30074 }
30075
30076
30077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30078   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30079
30080   arg1 = (Dali::GestureDetector *)jarg1;
30081   {
30082     try {
30083       delete arg1;
30084     } catch (std::out_of_range& e) {
30085       {
30086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30087       };
30088     } catch (std::exception& e) {
30089       {
30090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30091       };
30092     } catch (Dali::DaliException e) {
30093       {
30094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30099       };
30100     }
30101   }
30102
30103 }
30104
30105
30106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30107   void * jresult ;
30108   Dali::GestureDetector *arg1 = 0 ;
30109   Dali::GestureDetector *result = 0 ;
30110
30111   arg1 = (Dali::GestureDetector *)jarg1;
30112   if (!arg1) {
30113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30114     return 0;
30115   }
30116   {
30117     try {
30118       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30119     } catch (std::out_of_range& e) {
30120       {
30121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30122       };
30123     } catch (std::exception& e) {
30124       {
30125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30126       };
30127     } catch (Dali::DaliException e) {
30128       {
30129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30130       };
30131     } catch (...) {
30132       {
30133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30134       };
30135     }
30136   }
30137
30138   jresult = (void *)result;
30139   return jresult;
30140 }
30141
30142
30143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30144   void * jresult ;
30145   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30146   Dali::GestureDetector *arg2 = 0 ;
30147   Dali::GestureDetector *result = 0 ;
30148
30149   arg1 = (Dali::GestureDetector *)jarg1;
30150   arg2 = (Dali::GestureDetector *)jarg2;
30151   if (!arg2) {
30152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30153     return 0;
30154   }
30155   {
30156     try {
30157       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30158     } catch (std::out_of_range& e) {
30159       {
30160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30161       };
30162     } catch (std::exception& e) {
30163       {
30164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30165       };
30166     } catch (Dali::DaliException e) {
30167       {
30168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30169       };
30170     } catch (...) {
30171       {
30172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30173       };
30174     }
30175   }
30176
30177   jresult = (void *)result;
30178   return jresult;
30179 }
30180
30181
30182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30183   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30184   Dali::Actor arg2 ;
30185   Dali::Actor *argp2 ;
30186
30187   arg1 = (Dali::GestureDetector *)jarg1;
30188   argp2 = (Dali::Actor *)jarg2;
30189   if (!argp2) {
30190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30191     return ;
30192   }
30193   arg2 = *argp2;
30194   {
30195     try {
30196       (arg1)->Attach(arg2);
30197     } catch (std::out_of_range& e) {
30198       {
30199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30200       };
30201     } catch (std::exception& e) {
30202       {
30203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30204       };
30205     } catch (Dali::DaliException e) {
30206       {
30207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30208       };
30209     } catch (...) {
30210       {
30211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30212       };
30213     }
30214   }
30215
30216 }
30217
30218
30219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30220   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30221   Dali::Actor arg2 ;
30222   Dali::Actor *argp2 ;
30223
30224   arg1 = (Dali::GestureDetector *)jarg1;
30225   argp2 = (Dali::Actor *)jarg2;
30226   if (!argp2) {
30227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30228     return ;
30229   }
30230   arg2 = *argp2;
30231   {
30232     try {
30233       (arg1)->Detach(arg2);
30234     } catch (std::out_of_range& e) {
30235       {
30236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30237       };
30238     } catch (std::exception& e) {
30239       {
30240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30241       };
30242     } catch (Dali::DaliException e) {
30243       {
30244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30245       };
30246     } catch (...) {
30247       {
30248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30249       };
30250     }
30251   }
30252
30253 }
30254
30255
30256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30257   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30258
30259   arg1 = (Dali::GestureDetector *)jarg1;
30260   {
30261     try {
30262       (arg1)->DetachAll();
30263     } catch (std::out_of_range& e) {
30264       {
30265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30266       };
30267     } catch (std::exception& e) {
30268       {
30269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30270       };
30271     } catch (Dali::DaliException e) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30274       };
30275     } catch (...) {
30276       {
30277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30278       };
30279     }
30280   }
30281
30282 }
30283
30284
30285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30286   unsigned long jresult ;
30287   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30288   size_t result;
30289
30290   arg1 = (Dali::GestureDetector *)jarg1;
30291   {
30292     try {
30293       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30294     } catch (std::out_of_range& e) {
30295       {
30296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (std::exception& e) {
30299       {
30300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30301       };
30302     } catch (Dali::DaliException e) {
30303       {
30304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30305       };
30306     } catch (...) {
30307       {
30308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30309       };
30310     }
30311   }
30312
30313   jresult = (unsigned long)result;
30314   return jresult;
30315 }
30316
30317
30318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30319   void * jresult ;
30320   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30321   size_t arg2 ;
30322   Dali::Actor result;
30323
30324   arg1 = (Dali::GestureDetector *)jarg1;
30325   arg2 = (size_t)jarg2;
30326   {
30327     try {
30328       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30329     } catch (std::out_of_range& e) {
30330       {
30331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30332       };
30333     } catch (std::exception& e) {
30334       {
30335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30336       };
30337     } catch (Dali::DaliException e) {
30338       {
30339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30340       };
30341     } catch (...) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30344       };
30345     }
30346   }
30347
30348   jresult = new Dali::Actor((const Dali::Actor &)result);
30349   return jresult;
30350 }
30351
30352
30353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30354   void * jresult ;
30355   Dali::Gesture *arg1 = 0 ;
30356   Dali::Gesture *result = 0 ;
30357
30358   arg1 = (Dali::Gesture *)jarg1;
30359   if (!arg1) {
30360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30361     return 0;
30362   }
30363   {
30364     try {
30365       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30366     } catch (std::out_of_range& e) {
30367       {
30368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30369       };
30370     } catch (std::exception& e) {
30371       {
30372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30373       };
30374     } catch (Dali::DaliException e) {
30375       {
30376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30377       };
30378     } catch (...) {
30379       {
30380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30381       };
30382     }
30383   }
30384
30385   jresult = (void *)result;
30386   return jresult;
30387 }
30388
30389
30390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30391   void * jresult ;
30392   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30393   Dali::Gesture *arg2 = 0 ;
30394   Dali::Gesture *result = 0 ;
30395
30396   arg1 = (Dali::Gesture *)jarg1;
30397   arg2 = (Dali::Gesture *)jarg2;
30398   if (!arg2) {
30399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30400     return 0;
30401   }
30402   {
30403     try {
30404       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30405     } catch (std::out_of_range& e) {
30406       {
30407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30408       };
30409     } catch (std::exception& e) {
30410       {
30411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30412       };
30413     } catch (Dali::DaliException e) {
30414       {
30415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30420       };
30421     }
30422   }
30423
30424   jresult = (void *)result;
30425   return jresult;
30426 }
30427
30428
30429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30430   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30431
30432   arg1 = (Dali::Gesture *)jarg1;
30433   {
30434     try {
30435       delete arg1;
30436     } catch (std::out_of_range& e) {
30437       {
30438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (std::exception& e) {
30441       {
30442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30443       };
30444     } catch (Dali::DaliException e) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30447       };
30448     } catch (...) {
30449       {
30450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30451       };
30452     }
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30459   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30460   Dali::Gesture::Type arg2 ;
30461
30462   arg1 = (Dali::Gesture *)jarg1;
30463   arg2 = (Dali::Gesture::Type)jarg2;
30464   if (arg1) (arg1)->type = arg2;
30465 }
30466
30467
30468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30469   int jresult ;
30470   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30471   Dali::Gesture::Type result;
30472
30473   arg1 = (Dali::Gesture *)jarg1;
30474   result = (Dali::Gesture::Type) ((arg1)->type);
30475   jresult = (int)result;
30476   return jresult;
30477 }
30478
30479
30480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30481   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30482   Dali::Gesture::State arg2 ;
30483
30484   arg1 = (Dali::Gesture *)jarg1;
30485   arg2 = (Dali::Gesture::State)jarg2;
30486   if (arg1) (arg1)->state = arg2;
30487 }
30488
30489
30490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30491   int jresult ;
30492   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30493   Dali::Gesture::State result;
30494
30495   arg1 = (Dali::Gesture *)jarg1;
30496   result = (Dali::Gesture::State) ((arg1)->state);
30497   jresult = (int)result;
30498   return jresult;
30499 }
30500
30501
30502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30503   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30504   unsigned int arg2 ;
30505
30506   arg1 = (Dali::Gesture *)jarg1;
30507   arg2 = (unsigned int)jarg2;
30508   if (arg1) (arg1)->time = arg2;
30509 }
30510
30511
30512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30513   unsigned int jresult ;
30514   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30515   unsigned int result;
30516
30517   arg1 = (Dali::Gesture *)jarg1;
30518   result = (unsigned int) ((arg1)->time);
30519   jresult = result;
30520   return jresult;
30521 }
30522
30523
30524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30525   void * jresult ;
30526   Dali::HoverEvent *result = 0 ;
30527
30528   {
30529     try {
30530       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30531     } catch (std::out_of_range& e) {
30532       {
30533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30534       };
30535     } catch (std::exception& e) {
30536       {
30537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (Dali::DaliException e) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30542       };
30543     } catch (...) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30546       };
30547     }
30548   }
30549
30550   jresult = (void *)result;
30551   return jresult;
30552 }
30553
30554
30555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
30556   void * jresult ;
30557   Dali::HoverEvent *arg1 = 0 ;
30558   Dali::HoverEvent *result = 0 ;
30559
30560   arg1 = (Dali::HoverEvent *)jarg1;
30561   if (!arg1) {
30562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30563     return 0;
30564   }
30565   {
30566     try {
30567       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30583       };
30584     }
30585   }
30586
30587   jresult = (void *)result;
30588   return jresult;
30589 }
30590
30591
30592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30593   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30594
30595   arg1 = (Dali::HoverEvent *)jarg1;
30596   {
30597     try {
30598       delete arg1;
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_Hover_Assign(void * jarg1, void * jarg2) {
30622   void * jresult ;
30623   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30624   Dali::HoverEvent *arg2 = 0 ;
30625   Dali::HoverEvent *result = 0 ;
30626
30627   arg1 = (Dali::HoverEvent *)jarg1;
30628   arg2 = (Dali::HoverEvent *)jarg2;
30629   if (!arg2) {
30630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30631     return 0;
30632   }
30633   {
30634     try {
30635       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30636     } catch (std::out_of_range& e) {
30637       {
30638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30639       };
30640     } catch (std::exception& e) {
30641       {
30642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30643       };
30644     } catch (Dali::DaliException e) {
30645       {
30646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30647       };
30648     } catch (...) {
30649       {
30650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30651       };
30652     }
30653   }
30654
30655   jresult = (void *)result;
30656   return jresult;
30657 }
30658
30659
30660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30661   unsigned long jresult ;
30662   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30663   unsigned long result;
30664
30665   arg1 = (Dali::HoverEvent *)jarg1;
30666   {
30667     try {
30668       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (Dali::DaliException e) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30680       };
30681     } catch (...) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30684       };
30685     }
30686   }
30687
30688   jresult = (unsigned long)result;
30689   return jresult;
30690 }
30691
30692
30693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30694   unsigned long jresult ;
30695   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30696   std::size_t result;
30697
30698   arg1 = (Dali::HoverEvent *)jarg1;
30699   {
30700     try {
30701       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30702     } catch (std::out_of_range& e) {
30703       {
30704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30705       };
30706     } catch (std::exception& e) {
30707       {
30708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30709       };
30710     } catch (Dali::DaliException e) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30713       };
30714     } catch (...) {
30715       {
30716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30717       };
30718     }
30719   }
30720
30721   jresult = (unsigned long)result;
30722   return jresult;
30723 }
30724
30725
30726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30727   int jresult ;
30728   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30729   std::size_t arg2 ;
30730   int32_t result;
30731
30732   arg1 = (Dali::HoverEvent *)jarg1;
30733   arg2 = (std::size_t)jarg2;
30734   {
30735     try {
30736       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30737     } catch (std::out_of_range& e) {
30738       {
30739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30740       };
30741     } catch (std::exception& e) {
30742       {
30743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30744       };
30745     } catch (Dali::DaliException e) {
30746       {
30747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30748       };
30749     } catch (...) {
30750       {
30751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30752       };
30753     }
30754   }
30755
30756   jresult = result;
30757   return jresult;
30758 }
30759
30760
30761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30762   int jresult ;
30763   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30764   std::size_t arg2 ;
30765   Dali::PointState::Type result;
30766
30767   arg1 = (Dali::HoverEvent *)jarg1;
30768   arg2 = (std::size_t)jarg2;
30769   {
30770     try {
30771       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30772     } catch (std::out_of_range& e) {
30773       {
30774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30775       };
30776     } catch (std::exception& e) {
30777       {
30778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30779       };
30780     } catch (Dali::DaliException e) {
30781       {
30782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30783       };
30784     } catch (...) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30787       };
30788     }
30789   }
30790
30791   jresult = (int)result;
30792   return jresult;
30793 }
30794
30795
30796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30797   void * jresult ;
30798   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30799   std::size_t arg2 ;
30800   Dali::Actor result;
30801
30802   arg1 = (Dali::HoverEvent *)jarg1;
30803   arg2 = (std::size_t)jarg2;
30804   {
30805     try {
30806       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30807     } catch (std::out_of_range& e) {
30808       {
30809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30810       };
30811     } catch (std::exception& e) {
30812       {
30813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30814       };
30815     } catch (Dali::DaliException e) {
30816       {
30817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30818       };
30819     } catch (...) {
30820       {
30821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30822       };
30823     }
30824   }
30825
30826   jresult = new Dali::Actor((const Dali::Actor &)result);
30827   return jresult;
30828 }
30829
30830
30831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30832   void * jresult ;
30833   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30834   std::size_t arg2 ;
30835   Dali::Vector2 *result = 0 ;
30836
30837   arg1 = (Dali::HoverEvent *)jarg1;
30838   arg2 = (std::size_t)jarg2;
30839   {
30840     try {
30841       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30842     } catch (std::out_of_range& e) {
30843       {
30844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30845       };
30846     } catch (std::exception& e) {
30847       {
30848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30849       };
30850     } catch (Dali::DaliException e) {
30851       {
30852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30853       };
30854     } catch (...) {
30855       {
30856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30857       };
30858     }
30859   }
30860
30861   jresult = (void *)result;
30862   return jresult;
30863 }
30864
30865
30866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30867   void * jresult ;
30868   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30869   std::size_t arg2 ;
30870   Dali::Vector2 *result = 0 ;
30871
30872   arg1 = (Dali::HoverEvent *)jarg1;
30873   arg2 = (std::size_t)jarg2;
30874   {
30875     try {
30876       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30877     } catch (std::out_of_range& e) {
30878       {
30879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30880       };
30881     } catch (std::exception& e) {
30882       {
30883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30884       };
30885     } catch (Dali::DaliException e) {
30886       {
30887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30888       };
30889     } catch (...) {
30890       {
30891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30892       };
30893     }
30894   }
30895
30896   jresult = (void *)result;
30897   return jresult;
30898 }
30899
30900
30901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30902   void * jresult ;
30903   Dali::KeyEvent *result = 0 ;
30904
30905   {
30906     try {
30907       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30908     } catch (std::out_of_range& e) {
30909       {
30910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30911       };
30912     } catch (std::exception& e) {
30913       {
30914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30915       };
30916     } catch (Dali::DaliException e) {
30917       {
30918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30919       };
30920     } catch (...) {
30921       {
30922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30923       };
30924     }
30925   }
30926
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30933   void * jresult ;
30934   std::string *arg1 = 0 ;
30935   std::string *arg2 = 0 ;
30936   int arg3 ;
30937   int arg4 ;
30938   unsigned long arg5 ;
30939   Dali::KeyEvent::State *arg6 = 0 ;
30940   Dali::KeyEvent::State temp6 ;
30941   Dali::KeyEvent *result = 0 ;
30942
30943   if (!jarg1) {
30944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30945     return 0;
30946   }
30947   std::string arg1_str(jarg1);
30948   arg1 = &arg1_str;
30949   if (!jarg2) {
30950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30951     return 0;
30952   }
30953   std::string arg2_str(jarg2);
30954   arg2 = &arg2_str;
30955   arg3 = (int)jarg3;
30956   arg4 = (int)jarg4;
30957   arg5 = (unsigned long)jarg5;
30958   temp6 = (Dali::KeyEvent::State)jarg6;
30959   arg6 = &temp6;
30960   {
30961     try {
30962       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = (void *)result;
30983
30984   //argout typemap for const std::string&
30985
30986
30987   //argout typemap for const std::string&
30988
30989   return jresult;
30990 }
30991
30992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30993   void * jresult ;
30994   Dali::KeyEvent *arg1 = 0 ;
30995   Dali::KeyEvent *result = 0 ;
30996
30997   arg1 = (Dali::KeyEvent *)jarg1;
30998   if (!arg1) {
30999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31000     return 0;
31001   }
31002   {
31003     try {
31004       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31005     } catch (std::out_of_range& e) {
31006       {
31007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31008       };
31009     } catch (std::exception& e) {
31010       {
31011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31012       };
31013     } catch (Dali::DaliException e) {
31014       {
31015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31016       };
31017     } catch (...) {
31018       {
31019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31020       };
31021     }
31022   }
31023
31024   jresult = (void *)result;
31025   return jresult;
31026 }
31027
31028
31029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31030   void * jresult ;
31031   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31032   Dali::KeyEvent *arg2 = 0 ;
31033   Dali::KeyEvent *result = 0 ;
31034
31035   arg1 = (Dali::KeyEvent *)jarg1;
31036   arg2 = (Dali::KeyEvent *)jarg2;
31037   if (!arg2) {
31038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31039     return 0;
31040   }
31041   {
31042     try {
31043       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31044     } catch (std::out_of_range& e) {
31045       {
31046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31047       };
31048     } catch (std::exception& e) {
31049       {
31050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31051       };
31052     } catch (Dali::DaliException e) {
31053       {
31054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31055       };
31056     } catch (...) {
31057       {
31058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31059       };
31060     }
31061   }
31062
31063   jresult = (void *)result;
31064   return jresult;
31065 }
31066
31067
31068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31069   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31070
31071   arg1 = (Dali::KeyEvent *)jarg1;
31072   {
31073     try {
31074       delete arg1;
31075     } catch (std::out_of_range& e) {
31076       {
31077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31078       };
31079     } catch (std::exception& e) {
31080       {
31081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31082       };
31083     } catch (Dali::DaliException e) {
31084       {
31085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31086       };
31087     } catch (...) {
31088       {
31089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31090       };
31091     }
31092   }
31093
31094 }
31095
31096
31097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31098   unsigned int jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   bool result;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   {
31104     try {
31105       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31106     } catch (std::out_of_range& e) {
31107       {
31108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31109       };
31110     } catch (std::exception& e) {
31111       {
31112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (Dali::DaliException e) {
31115       {
31116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31117       };
31118     } catch (...) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31121       };
31122     }
31123   }
31124
31125   jresult = result;
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31131   unsigned int jresult ;
31132   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31133   bool result;
31134
31135   arg1 = (Dali::KeyEvent *)jarg1;
31136   {
31137     try {
31138       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31146       };
31147     } catch (Dali::DaliException e) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31150       };
31151     } catch (...) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31154       };
31155     }
31156   }
31157
31158   jresult = result;
31159   return jresult;
31160 }
31161
31162
31163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31164   unsigned int jresult ;
31165   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31166   bool result;
31167
31168   arg1 = (Dali::KeyEvent *)jarg1;
31169   {
31170     try {
31171       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31172     } catch (std::out_of_range& e) {
31173       {
31174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31175       };
31176     } catch (std::exception& e) {
31177       {
31178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31179       };
31180     } catch (Dali::DaliException e) {
31181       {
31182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31183       };
31184     } catch (...) {
31185       {
31186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31187       };
31188     }
31189   }
31190
31191   jresult = result;
31192   return jresult;
31193 }
31194
31195
31196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31197   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31198   std::string *arg2 = 0 ;
31199
31200   arg1 = (Dali::KeyEvent *)jarg1;
31201   if (!jarg2) {
31202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31203     return ;
31204   }
31205   std::string arg2_str(jarg2);
31206   arg2 = &arg2_str;
31207   if (arg1) (arg1)->keyPressedName = *arg2;
31208
31209   //argout typemap for const std::string&
31210
31211 }
31212
31213
31214 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31215   char * jresult ;
31216
31217   if( jarg1 == NULL )
31218   {
31219     jresult = SWIG_csharp_string_callback( "" );
31220   }
31221   else
31222   {
31223     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31224     std::string *result = 0;
31225
31226     arg1 = ( Dali::KeyEvent * )jarg1;
31227     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31228     jresult = SWIG_csharp_string_callback( result->c_str() );
31229   }
31230
31231   return jresult;
31232 }
31233
31234
31235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31236   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31237   std::string *arg2 = 0 ;
31238
31239   arg1 = (Dali::KeyEvent *)jarg1;
31240   if (!jarg2) {
31241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31242     return ;
31243   }
31244   std::string arg2_str(jarg2);
31245   arg2 = &arg2_str;
31246   if (arg1) (arg1)->keyPressed = *arg2;
31247
31248   //argout typemap for const std::string&
31249
31250 }
31251
31252
31253 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31254   char * jresult ;
31255   if( NULL == jarg1 )
31256   {
31257     jresult = SWIG_csharp_string_callback( "" );
31258   }
31259   else
31260   {
31261     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31262     std::string *result = 0;
31263
31264     arg1 = ( Dali::KeyEvent * )jarg1;
31265     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31266     jresult = SWIG_csharp_string_callback( result->c_str() );
31267   }
31268   return jresult;
31269 }
31270
31271
31272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31273   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31274   int arg2 ;
31275
31276   arg1 = (Dali::KeyEvent *)jarg1;
31277   arg2 = (int)jarg2;
31278   if (arg1) (arg1)->keyCode = arg2;
31279 }
31280
31281
31282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31283   int jresult ;
31284   if( NULL == jarg1 )
31285   {
31286     jresult = -1;
31287   }
31288   else
31289   {
31290     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31291     int result;
31292
31293     arg1 = ( Dali::KeyEvent * )jarg1;
31294     result = (int)( ( arg1 )->keyCode );
31295     jresult = result;
31296   }
31297   return jresult;
31298 }
31299
31300
31301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31302   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31303   int arg2 ;
31304
31305   arg1 = (Dali::KeyEvent *)jarg1;
31306   arg2 = (int)jarg2;
31307   if (arg1) (arg1)->keyModifier = arg2;
31308 }
31309
31310
31311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31312   int jresult ;
31313   if( jarg1 == NULL )
31314   {
31315     jresult = -1;
31316   }
31317   else
31318   {
31319     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31320     int result;
31321
31322     arg1 = ( Dali::KeyEvent * )jarg1;
31323     result = (int)( ( arg1 )->keyModifier );
31324     jresult = result;
31325   }
31326   return jresult;
31327 }
31328
31329
31330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31331   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31332   unsigned long arg2 ;
31333
31334   arg1 = (Dali::KeyEvent *)jarg1;
31335   arg2 = (unsigned long)jarg2;
31336   if (arg1) (arg1)->time = arg2;
31337 }
31338
31339
31340 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31341   unsigned long jresult ;
31342   if( jarg1 == NULL )
31343   {
31344     jresult = 0;
31345   }
31346   else
31347   {
31348     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31349     unsigned long result;
31350
31351     arg1 = ( Dali::KeyEvent * )jarg1;
31352     result = (unsigned long)( ( arg1 )->time );
31353     jresult = (unsigned long)result;
31354   }
31355   return jresult;
31356 }
31357
31358
31359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31360   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31361   Dali::KeyEvent::State arg2 ;
31362
31363   arg1 = (Dali::KeyEvent *)jarg1;
31364   arg2 = (Dali::KeyEvent::State)jarg2;
31365   if (arg1) (arg1)->state = arg2;
31366 }
31367
31368
31369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31370   int jresult ;
31371   if( jarg1 == NULL )
31372   {
31373     jresult = -1;
31374   }
31375   else
31376   {
31377     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31378     Dali::KeyEvent::State result;
31379
31380     arg1 = ( Dali::KeyEvent * )jarg1;
31381     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31382     jresult = (int)result;
31383   }
31384   return jresult;
31385 }
31386
31387 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31388   char * jresult ;
31389   std::string result;
31390   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31391
31392   arg1 = (Dali::KeyEvent *)jarg1;
31393   if (!arg1) {
31394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31395     return 0;
31396   }
31397   {
31398     try {
31399       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31400     } catch (std::out_of_range& e) {
31401       {
31402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31403       };
31404     } catch (std::exception& e) {
31405       {
31406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31407       };
31408     } catch (Dali::DaliException e) {
31409       {
31410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31411       };
31412     } catch (...) {
31413       {
31414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31415       };
31416     }
31417
31418   }
31419
31420   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31426   void * jresult ;
31427   Dali::LongPressGestureDetector *result = 0 ;
31428
31429   {
31430     try {
31431       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31432     } catch (std::out_of_range& e) {
31433       {
31434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31435       };
31436     } catch (std::exception& e) {
31437       {
31438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31439       };
31440     } catch (Dali::DaliException e) {
31441       {
31442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31443       };
31444     } catch (...) {
31445       {
31446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31447       };
31448     }
31449   }
31450
31451   jresult = (void *)result;
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31457   void * jresult ;
31458   Dali::LongPressGestureDetector result;
31459
31460   {
31461     try {
31462       result = Dali::LongPressGestureDetector::New();
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31488   void * jresult ;
31489   unsigned int arg1 ;
31490   Dali::LongPressGestureDetector result;
31491
31492   arg1 = (unsigned int)jarg1;
31493   {
31494     try {
31495       result = Dali::LongPressGestureDetector::New(arg1);
31496     } catch (std::out_of_range& e) {
31497       {
31498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31499       };
31500     } catch (std::exception& e) {
31501       {
31502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31503       };
31504     } catch (Dali::DaliException e) {
31505       {
31506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31507       };
31508     } catch (...) {
31509       {
31510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31511       };
31512     }
31513   }
31514
31515   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31516   return jresult;
31517 }
31518
31519
31520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31521   void * jresult ;
31522   unsigned int arg1 ;
31523   unsigned int arg2 ;
31524   Dali::LongPressGestureDetector result;
31525
31526   arg1 = (unsigned int)jarg1;
31527   arg2 = (unsigned int)jarg2;
31528   {
31529     try {
31530       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31531     } catch (std::out_of_range& e) {
31532       {
31533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31534       };
31535     } catch (std::exception& e) {
31536       {
31537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31538       };
31539     } catch (Dali::DaliException e) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31542       };
31543     } catch (...) {
31544       {
31545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31546       };
31547     }
31548   }
31549
31550   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31551   return jresult;
31552 }
31553
31554
31555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31556   void * jresult ;
31557   Dali::BaseHandle arg1 ;
31558   Dali::BaseHandle *argp1 ;
31559   Dali::LongPressGestureDetector result;
31560
31561   argp1 = (Dali::BaseHandle *)jarg1;
31562   if (!argp1) {
31563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31564     return 0;
31565   }
31566   arg1 = *argp1;
31567   {
31568     try {
31569       result = Dali::LongPressGestureDetector::DownCast(arg1);
31570     } catch (std::out_of_range& e) {
31571       {
31572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31573       };
31574     } catch (std::exception& e) {
31575       {
31576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31577       };
31578     } catch (Dali::DaliException e) {
31579       {
31580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31581       };
31582     } catch (...) {
31583       {
31584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31585       };
31586     }
31587   }
31588
31589   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31590   return jresult;
31591 }
31592
31593
31594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31595   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31596
31597   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31598   {
31599     try {
31600       delete arg1;
31601     } catch (std::out_of_range& e) {
31602       {
31603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31604       };
31605     } catch (std::exception& e) {
31606       {
31607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31608       };
31609     } catch (Dali::DaliException e) {
31610       {
31611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31612       };
31613     } catch (...) {
31614       {
31615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31616       };
31617     }
31618   }
31619
31620 }
31621
31622
31623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31624   void * jresult ;
31625   Dali::LongPressGestureDetector *arg1 = 0 ;
31626   Dali::LongPressGestureDetector *result = 0 ;
31627
31628   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31629   if (!arg1) {
31630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31631     return 0;
31632   }
31633   {
31634     try {
31635       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31636     } catch (std::out_of_range& e) {
31637       {
31638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31639       };
31640     } catch (std::exception& e) {
31641       {
31642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31643       };
31644     } catch (Dali::DaliException e) {
31645       {
31646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31647       };
31648     } catch (...) {
31649       {
31650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31651       };
31652     }
31653   }
31654
31655   jresult = (void *)result;
31656   return jresult;
31657 }
31658
31659
31660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31661   void * jresult ;
31662   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31663   Dali::LongPressGestureDetector *arg2 = 0 ;
31664   Dali::LongPressGestureDetector *result = 0 ;
31665
31666   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31667   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31668   if (!arg2) {
31669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31670     return 0;
31671   }
31672   {
31673     try {
31674       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31675     } catch (std::out_of_range& e) {
31676       {
31677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31678       };
31679     } catch (std::exception& e) {
31680       {
31681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31682       };
31683     } catch (Dali::DaliException e) {
31684       {
31685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31690       };
31691     }
31692   }
31693
31694   jresult = (void *)result;
31695   return jresult;
31696 }
31697
31698
31699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31700   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31701   unsigned int arg2 ;
31702
31703   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31704   arg2 = (unsigned int)jarg2;
31705   {
31706     try {
31707       (arg1)->SetTouchesRequired(arg2);
31708     } catch (std::out_of_range& e) {
31709       {
31710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31711       };
31712     } catch (std::exception& e) {
31713       {
31714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31715       };
31716     } catch (Dali::DaliException e) {
31717       {
31718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31719       };
31720     } catch (...) {
31721       {
31722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31723       };
31724     }
31725   }
31726
31727 }
31728
31729
31730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   unsigned int arg2 ;
31733   unsigned int arg3 ;
31734
31735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31736   arg2 = (unsigned int)jarg2;
31737   arg3 = (unsigned int)jarg3;
31738   {
31739     try {
31740       (arg1)->SetTouchesRequired(arg2,arg3);
31741     } catch (std::out_of_range& e) {
31742       {
31743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (std::exception& e) {
31746       {
31747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31748       };
31749     } catch (Dali::DaliException e) {
31750       {
31751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31752       };
31753     } catch (...) {
31754       {
31755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31756       };
31757     }
31758   }
31759
31760 }
31761
31762
31763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31764   unsigned int jresult ;
31765   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31766   unsigned int result;
31767
31768   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31769   {
31770     try {
31771       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31787       };
31788     }
31789   }
31790
31791   jresult = result;
31792   return jresult;
31793 }
31794
31795
31796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31797   unsigned int jresult ;
31798   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31799   unsigned int result;
31800
31801   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31802   {
31803     try {
31804       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31805     } catch (std::out_of_range& e) {
31806       {
31807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (std::exception& e) {
31810       {
31811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31812       };
31813     } catch (Dali::DaliException e) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31816       };
31817     } catch (...) {
31818       {
31819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31820       };
31821     }
31822   }
31823
31824   jresult = result;
31825   return jresult;
31826 }
31827
31828
31829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31830   void * jresult ;
31831   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31832   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31833
31834   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31835   {
31836     try {
31837       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31838     } catch (std::out_of_range& e) {
31839       {
31840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31841       };
31842     } catch (std::exception& e) {
31843       {
31844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (Dali::DaliException e) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856
31857   jresult = (void *)result;
31858   return jresult;
31859 }
31860
31861
31862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31863   void * jresult ;
31864   Dali::Gesture::State arg1 ;
31865   Dali::LongPressGesture *result = 0 ;
31866
31867   arg1 = (Dali::Gesture::State)jarg1;
31868   {
31869     try {
31870       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31871     } catch (std::out_of_range& e) {
31872       {
31873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (std::exception& e) {
31876       {
31877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (Dali::DaliException e) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31882       };
31883     } catch (...) {
31884       {
31885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31886       };
31887     }
31888   }
31889
31890   jresult = (void *)result;
31891   return jresult;
31892 }
31893
31894
31895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31896   void * jresult ;
31897   Dali::LongPressGesture *arg1 = 0 ;
31898   Dali::LongPressGesture *result = 0 ;
31899
31900   arg1 = (Dali::LongPressGesture *)jarg1;
31901   if (!arg1) {
31902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31903     return 0;
31904   }
31905   {
31906     try {
31907       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31908     } catch (std::out_of_range& e) {
31909       {
31910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31911       };
31912     } catch (std::exception& e) {
31913       {
31914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31915       };
31916     } catch (Dali::DaliException e) {
31917       {
31918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31919       };
31920     } catch (...) {
31921       {
31922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31923       };
31924     }
31925   }
31926
31927   jresult = (void *)result;
31928   return jresult;
31929 }
31930
31931
31932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31933   void * jresult ;
31934   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31935   Dali::LongPressGesture *arg2 = 0 ;
31936   Dali::LongPressGesture *result = 0 ;
31937
31938   arg1 = (Dali::LongPressGesture *)jarg1;
31939   arg2 = (Dali::LongPressGesture *)jarg2;
31940   if (!arg2) {
31941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31942     return 0;
31943   }
31944   {
31945     try {
31946       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31947     } catch (std::out_of_range& e) {
31948       {
31949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31950       };
31951     } catch (std::exception& e) {
31952       {
31953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31954       };
31955     } catch (Dali::DaliException e) {
31956       {
31957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31958       };
31959     } catch (...) {
31960       {
31961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31962       };
31963     }
31964   }
31965
31966   jresult = (void *)result;
31967   return jresult;
31968 }
31969
31970
31971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31972   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31973
31974   arg1 = (Dali::LongPressGesture *)jarg1;
31975   {
31976     try {
31977       delete arg1;
31978     } catch (std::out_of_range& e) {
31979       {
31980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31981       };
31982     } catch (std::exception& e) {
31983       {
31984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31985       };
31986     } catch (Dali::DaliException e) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31989       };
31990     } catch (...) {
31991       {
31992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31993       };
31994     }
31995   }
31996
31997 }
31998
31999
32000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32001   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32002   unsigned int arg2 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   arg2 = (unsigned int)jarg2;
32006   if (arg1) (arg1)->numberOfTouches = arg2;
32007 }
32008
32009
32010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32011   unsigned int jresult ;
32012   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32013   unsigned int result;
32014
32015   arg1 = (Dali::LongPressGesture *)jarg1;
32016   result = (unsigned int) ((arg1)->numberOfTouches);
32017   jresult = result;
32018   return jresult;
32019 }
32020
32021
32022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32023   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32024   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32025
32026   arg1 = (Dali::LongPressGesture *)jarg1;
32027   arg2 = (Dali::Vector2 *)jarg2;
32028   if (arg1) (arg1)->screenPoint = *arg2;
32029 }
32030
32031
32032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32033   void * jresult ;
32034   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32035   Dali::Vector2 *result = 0 ;
32036
32037   arg1 = (Dali::LongPressGesture *)jarg1;
32038   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32039   jresult = (void *)result;
32040   return jresult;
32041 }
32042
32043
32044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32045   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32046   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32047
32048   arg1 = (Dali::LongPressGesture *)jarg1;
32049   arg2 = (Dali::Vector2 *)jarg2;
32050   if (arg1) (arg1)->localPoint = *arg2;
32051 }
32052
32053
32054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32055   void * jresult ;
32056   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32057   Dali::Vector2 *result = 0 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32061   jresult = (void *)result;
32062   return jresult;
32063 }
32064
32065
32066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32067   void * jresult ;
32068   Dali::WheelEvent *result = 0 ;
32069
32070   {
32071     try {
32072       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32073     } catch (std::out_of_range& e) {
32074       {
32075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32076       };
32077     } catch (std::exception& e) {
32078       {
32079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32080       };
32081     } catch (Dali::DaliException e) {
32082       {
32083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32084       };
32085     } catch (...) {
32086       {
32087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32088       };
32089     }
32090   }
32091
32092   jresult = (void *)result;
32093   return jresult;
32094 }
32095
32096
32097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32098   void * jresult ;
32099   Dali::WheelEvent::Type arg1 ;
32100   int arg2 ;
32101   unsigned int arg3 ;
32102   Dali::Vector2 arg4 ;
32103   int arg5 ;
32104   unsigned int arg6 ;
32105   Dali::Vector2 *argp4 ;
32106   Dali::WheelEvent *result = 0 ;
32107
32108   arg1 = (Dali::WheelEvent::Type)jarg1;
32109   arg2 = (int)jarg2;
32110   arg3 = (unsigned int)jarg3;
32111   argp4 = (Dali::Vector2 *)jarg4;
32112   if (!argp4) {
32113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32114     return 0;
32115   }
32116   arg4 = *argp4;
32117   arg5 = (int)jarg5;
32118   arg6 = (unsigned int)jarg6;
32119   {
32120     try {
32121       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32122     } catch (std::out_of_range& e) {
32123       {
32124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32125       };
32126     } catch (std::exception& e) {
32127       {
32128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32129       };
32130     } catch (Dali::DaliException e) {
32131       {
32132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32133       };
32134     } catch (...) {
32135       {
32136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32137       };
32138     }
32139   }
32140
32141   jresult = (void *)result;
32142   return jresult;
32143 }
32144
32145
32146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32147   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32148
32149   arg1 = (Dali::WheelEvent *)jarg1;
32150   {
32151     try {
32152       delete arg1;
32153     } catch (std::out_of_range& e) {
32154       {
32155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32156       };
32157     } catch (std::exception& e) {
32158       {
32159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32160       };
32161     } catch (Dali::DaliException e) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32164       };
32165     } catch (...) {
32166       {
32167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32168       };
32169     }
32170   }
32171
32172 }
32173
32174
32175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32176   unsigned int jresult ;
32177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32178   bool result;
32179
32180   arg1 = (Dali::WheelEvent *)jarg1;
32181   {
32182     try {
32183       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32191       };
32192     } catch (Dali::DaliException e) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32195       };
32196     } catch (...) {
32197       {
32198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32199       };
32200     }
32201   }
32202
32203   jresult = result;
32204   return jresult;
32205 }
32206
32207
32208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32209   unsigned int jresult ;
32210   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32211   bool result;
32212
32213   arg1 = (Dali::WheelEvent *)jarg1;
32214   {
32215     try {
32216       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32217     } catch (std::out_of_range& e) {
32218       {
32219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32220       };
32221     } catch (std::exception& e) {
32222       {
32223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32224       };
32225     } catch (Dali::DaliException e) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32228       };
32229     } catch (...) {
32230       {
32231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32232       };
32233     }
32234   }
32235
32236   jresult = result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32242   unsigned int jresult ;
32243   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32244   bool result;
32245
32246   arg1 = (Dali::WheelEvent *)jarg1;
32247   {
32248     try {
32249       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32250     } catch (std::out_of_range& e) {
32251       {
32252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32253       };
32254     } catch (std::exception& e) {
32255       {
32256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32257       };
32258     } catch (Dali::DaliException e) {
32259       {
32260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32261       };
32262     } catch (...) {
32263       {
32264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32265       };
32266     }
32267   }
32268
32269   jresult = result;
32270   return jresult;
32271 }
32272
32273
32274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32276   Dali::WheelEvent::Type arg2 ;
32277
32278   arg1 = (Dali::WheelEvent *)jarg1;
32279   arg2 = (Dali::WheelEvent::Type)jarg2;
32280   if (arg1) (arg1)->type = arg2;
32281 }
32282
32283
32284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32285   int jresult ;
32286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32287   Dali::WheelEvent::Type result;
32288
32289   arg1 = (Dali::WheelEvent *)jarg1;
32290   result = (Dali::WheelEvent::Type) ((arg1)->type);
32291   jresult = (int)result;
32292   return jresult;
32293 }
32294
32295
32296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32297   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32298   int arg2 ;
32299
32300   arg1 = (Dali::WheelEvent *)jarg1;
32301   arg2 = (int)jarg2;
32302   if (arg1) (arg1)->direction = arg2;
32303 }
32304
32305
32306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32307   int jresult ;
32308   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32309   int result;
32310
32311   arg1 = (Dali::WheelEvent *)jarg1;
32312   result = (int) ((arg1)->direction);
32313   jresult = result;
32314   return jresult;
32315 }
32316
32317
32318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32319   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32320   unsigned int arg2 ;
32321
32322   arg1 = (Dali::WheelEvent *)jarg1;
32323   arg2 = (unsigned int)jarg2;
32324   if (arg1) (arg1)->modifiers = arg2;
32325 }
32326
32327
32328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32329   unsigned int jresult ;
32330   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32331   unsigned int result;
32332
32333   arg1 = (Dali::WheelEvent *)jarg1;
32334   result = (unsigned int) ((arg1)->modifiers);
32335   jresult = result;
32336   return jresult;
32337 }
32338
32339
32340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32341   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32342   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32343
32344   arg1 = (Dali::WheelEvent *)jarg1;
32345   arg2 = (Dali::Vector2 *)jarg2;
32346   if (arg1) (arg1)->point = *arg2;
32347 }
32348
32349
32350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32351   void * jresult ;
32352   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32353   Dali::Vector2 *result = 0 ;
32354
32355   arg1 = (Dali::WheelEvent *)jarg1;
32356   result = (Dali::Vector2 *)& ((arg1)->point);
32357   jresult = (void *)result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32363   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32364   int arg2 ;
32365
32366   arg1 = (Dali::WheelEvent *)jarg1;
32367   arg2 = (int)jarg2;
32368   if (arg1) (arg1)->z = arg2;
32369 }
32370
32371
32372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32373   int jresult ;
32374   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32375   int result;
32376
32377   arg1 = (Dali::WheelEvent *)jarg1;
32378   result = (int) ((arg1)->z);
32379   jresult = result;
32380   return jresult;
32381 }
32382
32383
32384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32385   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32386   unsigned int arg2 ;
32387
32388   arg1 = (Dali::WheelEvent *)jarg1;
32389   arg2 = (unsigned int)jarg2;
32390   if (arg1) (arg1)->timeStamp = arg2;
32391 }
32392
32393
32394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32395   unsigned int jresult ;
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   unsigned int result;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   result = (unsigned int) ((arg1)->timeStamp);
32401   jresult = result;
32402   return jresult;
32403 }
32404
32405 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32406   char * jresult ;
32407   Dali::KeyEvent *arg1 = 0 ;
32408   std::string result;
32409
32410   arg1 = (Dali::KeyEvent *)jarg1;
32411   if (!arg1) {
32412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32413     return 0;
32414   }
32415   {
32416     try {
32417       result = arg1->GetDeviceName();
32418     } catch (std::out_of_range& e) {
32419       {
32420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32421       };
32422     } catch (std::exception& e) {
32423       {
32424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32425       };
32426     } catch (Dali::DaliException e) {
32427       {
32428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32429       };
32430     } catch (...) {
32431       {
32432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32433       };
32434     }
32435   }
32436
32437   jresult = SWIG_csharp_string_callback((&result)->c_str());
32438   return jresult;
32439 }
32440
32441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32442   int jresult ;
32443   Dali::KeyEvent *arg1 = 0 ;
32444   Dali::Device::Class::Type result;
32445
32446   arg1 = (Dali::KeyEvent *)jarg1;
32447   if (!arg1) {
32448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32449     return 0;
32450   }
32451   {
32452     try {
32453       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32454     } catch (std::out_of_range& e) {
32455       {
32456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32457       };
32458     } catch (std::exception& e) {
32459       {
32460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32461       };
32462     } catch (Dali::DaliException e) {
32463       {
32464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32465       };
32466     } catch (...) {
32467       {
32468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32469       };
32470     }
32471   }
32472
32473   jresult = (int)result;
32474   return jresult;
32475 }
32476
32477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32478   int jresult ;
32479   Dali::KeyEvent *arg1 = 0 ;
32480   Dali::Device::Subclass::Type result;
32481
32482   arg1 = (Dali::KeyEvent *)jarg1;
32483   if (!arg1) {
32484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32485     return 0;
32486   }
32487   {
32488     try {
32489       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32490     } catch (std::out_of_range& e) {
32491       {
32492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32493       };
32494     } catch (std::exception& e) {
32495       {
32496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32497       };
32498     } catch (Dali::DaliException e) {
32499       {
32500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32501       };
32502     } catch (...) {
32503       {
32504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32505       };
32506     }
32507   }
32508
32509   jresult = (int)result;
32510   return jresult;
32511 }
32512
32513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32514   Dali::Actor arg1 ;
32515   Dali::Actor *argp1 ;
32516
32517   argp1 = (Dali::Actor *)jarg1;
32518   if (!argp1) {
32519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32520     return ;
32521   }
32522   arg1 = *argp1;
32523   {
32524     try {
32525       arg1.Raise();
32526     } catch (std::out_of_range& e) {
32527       {
32528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32529       };
32530     } catch (std::exception& e) {
32531       {
32532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32533       };
32534     } catch (Dali::DaliException e) {
32535       {
32536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32537       };
32538     } catch (...) {
32539       {
32540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32541       };
32542     }
32543   }
32544
32545 }
32546
32547
32548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32549   Dali::Actor arg1 ;
32550   Dali::Actor *argp1 ;
32551
32552   argp1 = (Dali::Actor *)jarg1;
32553   if (!argp1) {
32554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32555     return ;
32556   }
32557   arg1 = *argp1;
32558   {
32559     try {
32560       arg1.Lower();
32561     } catch (std::out_of_range& e) {
32562       {
32563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32564       };
32565     } catch (std::exception& e) {
32566       {
32567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32568       };
32569     } catch (Dali::DaliException e) {
32570       {
32571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32572       };
32573     } catch (...) {
32574       {
32575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32576       };
32577     }
32578   }
32579
32580 }
32581
32582
32583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32584   Dali::Actor arg1 ;
32585   Dali::Actor *argp1 ;
32586
32587   argp1 = (Dali::Actor *)jarg1;
32588   if (!argp1) {
32589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32590     return ;
32591   }
32592   arg1 = *argp1;
32593   {
32594     try {
32595       arg1.RaiseToTop();
32596     } catch (std::out_of_range& e) {
32597       {
32598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32599       };
32600     } catch (std::exception& e) {
32601       {
32602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32603       };
32604     } catch (Dali::DaliException e) {
32605       {
32606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32607       };
32608     } catch (...) {
32609       {
32610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32611       };
32612     }
32613   }
32614
32615 }
32616
32617
32618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32619   Dali::Actor arg1 ;
32620   Dali::Actor *argp1 ;
32621
32622   argp1 = (Dali::Actor *)jarg1;
32623   if (!argp1) {
32624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32625     return ;
32626   }
32627   arg1 = *argp1;
32628   {
32629     try {
32630       arg1.LowerToBottom();
32631     } catch (std::out_of_range& e) {
32632       {
32633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32634       };
32635     } catch (std::exception& e) {
32636       {
32637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32638       };
32639     } catch (Dali::DaliException e) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32642       };
32643     } catch (...) {
32644       {
32645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32646       };
32647     }
32648   }
32649
32650 }
32651
32652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32653   Dali::Actor arg1 ;
32654   Dali::Actor arg2 ;
32655   Dali::Actor *argp1 ;
32656   Dali::Actor *argp2 ;
32657
32658   argp1 = (Dali::Actor *)jarg1;
32659   if (!argp1) {
32660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32661     return ;
32662   }
32663   arg1 = *argp1;
32664   argp2 = (Dali::Actor *)jarg2;
32665   if (!argp2) {
32666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32667     return ;
32668   }
32669   arg2 = *argp2;
32670   {
32671     try {
32672       arg1.RaiseAbove(arg2);
32673     } catch (std::out_of_range& e) {
32674       {
32675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32676       };
32677     } catch (std::exception& e) {
32678       {
32679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32680       };
32681     } catch (Dali::DaliException e) {
32682       {
32683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32684       };
32685     } catch (...) {
32686       {
32687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32688       };
32689     }
32690   }
32691
32692 }
32693
32694
32695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32696   Dali::Actor arg1 ;
32697   Dali::Actor arg2 ;
32698   Dali::Actor *argp1 ;
32699   Dali::Actor *argp2 ;
32700
32701   argp1 = (Dali::Actor *)jarg1;
32702   if (!argp1) {
32703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32704     return ;
32705   }
32706   arg1 = *argp1;
32707   argp2 = (Dali::Actor *)jarg2;
32708   if (!argp2) {
32709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32710     return ;
32711   }
32712   arg2 = *argp2;
32713   {
32714     try {
32715       arg1.LowerBelow(arg2);
32716     } catch (std::out_of_range& e) {
32717       {
32718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32719       };
32720     } catch (std::exception& e) {
32721       {
32722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32723       };
32724     } catch (Dali::DaliException e) {
32725       {
32726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32727       };
32728     } catch (...) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32731       };
32732     }
32733   }
32734
32735 }
32736
32737
32738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32739   void * jresult ;
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32743
32744   argp1 = (Dali::Actor *)jarg1;
32745   if (!argp1) {
32746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32747     return 0;
32748   }
32749   arg1 = *argp1;
32750   {
32751     try {
32752       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32760       };
32761     } catch (Dali::DaliException e) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32764       };
32765     } catch (...) {
32766       {
32767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32768       };
32769     }
32770   }
32771
32772   jresult = (void *)result;
32773   return jresult;
32774 }
32775
32776
32777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32778   void * jresult ;
32779   Dali::Actor *arg1 ;
32780   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32781
32782   arg1 = (Dali::Actor *)jarg1;
32783   {
32784     try {
32785       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32786     } catch (std::out_of_range& e) {
32787       {
32788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32789       };
32790     } catch (std::exception& e) {
32791       {
32792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32793       };
32794     } catch (Dali::DaliException e) {
32795       {
32796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32797       };
32798     } catch (...) {
32799       {
32800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32801       };
32802     }
32803   }
32804
32805   jresult = (void *)result;
32806   return jresult;
32807 }
32808
32809
32810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32811   int jresult ;
32812   int result;
32813
32814   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32815   jresult = (int)result;
32816   return jresult;
32817 }
32818
32819
32820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32821   int jresult ;
32822   int result;
32823
32824   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32825   jresult = (int)result;
32826   return jresult;
32827 }
32828
32829
32830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32831   int jresult ;
32832   int result;
32833
32834   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32835   jresult = (int)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::SIZE;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::POSITION;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::POSITION_X;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::POSITION_Y;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::POSITION_Z;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::WORLD_POSITION;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::ORIENTATION;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::SCALE;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::SCALE_X;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::SCALE_Y;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::SCALE_Z;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::WORLD_SCALE;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::VISIBLE;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::COLOR;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::COLOR_RED;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::COLOR_GREEN;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::COLOR_BLUE;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::WORLD_COLOR;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::NAME;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::SENSITIVE;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::COLOR_MODE;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::DRAW_MODE;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::PADDING;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33340
33341   return Dali::Actor::Property::OPACITY;
33342 }
33343
33344 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33345
33346   return Dali::Actor::Property::SCREEN_POSITION;
33347 }
33348
33349 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33350
33351   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33352 }
33353
33354 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33355   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33356 }
33357
33358 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33359   return Dali::Actor::Property::LAYOUT_DIRECTION;
33360 }
33361
33362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33363   void * jresult ;
33364   Dali::Actor::Property *result = 0 ;
33365
33366   {
33367     try {
33368       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33369     } catch (std::out_of_range& e) {
33370       {
33371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33372       };
33373     } catch (std::exception& e) {
33374       {
33375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (Dali::DaliException e) {
33378       {
33379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387
33388   jresult = (void *)result;
33389   return jresult;
33390 }
33391
33392
33393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33394   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33395
33396   arg1 = (Dali::Actor::Property *)jarg1;
33397   {
33398     try {
33399       delete arg1;
33400     } catch (std::out_of_range& e) {
33401       {
33402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33403       };
33404     } catch (std::exception& e) {
33405       {
33406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33407       };
33408     } catch (Dali::DaliException e) {
33409       {
33410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33411       };
33412     } catch (...) {
33413       {
33414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33415       };
33416     }
33417   }
33418
33419 }
33420
33421
33422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33423   void * jresult ;
33424   Dali::Actor *result = 0 ;
33425
33426   {
33427     try {
33428       result = (Dali::Actor *)new Dali::Actor();
33429     } catch (std::out_of_range& e) {
33430       {
33431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33432       };
33433     } catch (std::exception& e) {
33434       {
33435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33436       };
33437     } catch (Dali::DaliException e) {
33438       {
33439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33440       };
33441     } catch (...) {
33442       {
33443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33444       };
33445     }
33446   }
33447
33448   jresult = (void *)result;
33449   return jresult;
33450 }
33451
33452
33453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33454   void * jresult ;
33455   Dali::Actor result;
33456
33457   {
33458     try {
33459       result = Dali::Actor::New();
33460     } catch (std::out_of_range& e) {
33461       {
33462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33463       };
33464     } catch (std::exception& e) {
33465       {
33466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33467       };
33468     } catch (Dali::DaliException e) {
33469       {
33470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33471       };
33472     } catch (...) {
33473       {
33474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33475       };
33476     }
33477   }
33478
33479   jresult = new Dali::Actor((const Dali::Actor &)result);
33480   return jresult;
33481 }
33482
33483
33484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33485   void * jresult ;
33486   Dali::BaseHandle arg1 ;
33487   Dali::BaseHandle *argp1 ;
33488   Dali::Actor result;
33489
33490   argp1 = (Dali::BaseHandle *)jarg1;
33491   if (!argp1) {
33492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33493     return 0;
33494   }
33495   arg1 = *argp1;
33496   {
33497     try {
33498       result = Dali::Actor::DownCast(arg1);
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (Dali::DaliException e) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33514       };
33515     }
33516   }
33517
33518   jresult = new Dali::Actor((const Dali::Actor &)result);
33519   return jresult;
33520 }
33521
33522
33523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33525
33526   arg1 = (Dali::Actor *)jarg1;
33527   {
33528     try {
33529       delete arg1;
33530     } catch (std::out_of_range& e) {
33531       {
33532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33533       };
33534     } catch (std::exception& e) {
33535       {
33536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33537       };
33538     } catch (Dali::DaliException e) {
33539       {
33540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33541       };
33542     } catch (...) {
33543       {
33544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33545       };
33546     }
33547   }
33548
33549 }
33550
33551
33552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33553   void * jresult ;
33554   Dali::Actor *arg1 = 0 ;
33555   Dali::Actor *result = 0 ;
33556
33557   arg1 = (Dali::Actor *)jarg1;
33558   if (!arg1) {
33559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33560     return 0;
33561   }
33562   {
33563     try {
33564       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33565     } catch (std::out_of_range& e) {
33566       {
33567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33568       };
33569     } catch (std::exception& e) {
33570       {
33571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33572       };
33573     } catch (Dali::DaliException e) {
33574       {
33575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33576       };
33577     } catch (...) {
33578       {
33579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33580       };
33581     }
33582   }
33583
33584   jresult = (void *)result;
33585   return jresult;
33586 }
33587
33588
33589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33590   void * jresult ;
33591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33592   Dali::Actor *arg2 = 0 ;
33593   Dali::Actor *result = 0 ;
33594
33595   arg1 = (Dali::Actor *)jarg1;
33596   arg2 = (Dali::Actor *)jarg2;
33597   if (!arg2) {
33598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33599     return 0;
33600   }
33601   {
33602     try {
33603       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33604     } catch (std::out_of_range& e) {
33605       {
33606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33607       };
33608     } catch (std::exception& e) {
33609       {
33610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (Dali::DaliException e) {
33613       {
33614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33615       };
33616     } catch (...) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33619       };
33620     }
33621   }
33622
33623   jresult = (void *)result;
33624   return jresult;
33625 }
33626
33627
33628 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33629   char * jresult ;
33630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33631   std::string *result = 0 ;
33632
33633   arg1 = (Dali::Actor *)jarg1;
33634   {
33635     try {
33636       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33637       result = (std::string *) &name;
33638     } catch (std::out_of_range& e) {
33639       {
33640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33641       };
33642     } catch (std::exception& e) {
33643       {
33644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33645       };
33646     } catch (Dali::DaliException e) {
33647       {
33648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33649       };
33650     } catch (...) {
33651       {
33652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33653       };
33654     }
33655   }
33656
33657   jresult = SWIG_csharp_string_callback(result->c_str());
33658   return jresult;
33659 }
33660
33661
33662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33664   std::string *arg2 = 0 ;
33665
33666   arg1 = (Dali::Actor *)jarg1;
33667   if (!jarg2) {
33668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33669     return ;
33670   }
33671   std::string arg2_str(jarg2);
33672   arg2 = &arg2_str;
33673   {
33674     try {
33675       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33676     } catch (std::out_of_range& e) {
33677       {
33678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33679       };
33680     } catch (std::exception& e) {
33681       {
33682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33683       };
33684     } catch (Dali::DaliException e) {
33685       {
33686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33687       };
33688     } catch (...) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33691       };
33692     }
33693   }
33694
33695
33696   //argout typemap for const std::string&
33697
33698 }
33699
33700
33701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33702   unsigned int jresult ;
33703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33704   unsigned int result;
33705
33706   arg1 = (Dali::Actor *)jarg1;
33707
33708   if(!arg1) {
33709     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33710     return -1;
33711   }
33712
33713   {
33714     try {
33715       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33716     } catch (std::out_of_range& e) {
33717       {
33718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (std::exception& e) {
33721       {
33722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33723       };
33724     } catch (Dali::DaliException e) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33727       };
33728     } catch (...) {
33729       {
33730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33731       };
33732     }
33733   }
33734
33735   jresult = result;
33736   return jresult;
33737 }
33738
33739
33740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33741   unsigned int jresult ;
33742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33743   bool result;
33744
33745   arg1 = (Dali::Actor *)jarg1;
33746   {
33747     try {
33748       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (Dali::DaliException e) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33760       };
33761     } catch (...) {
33762       {
33763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33764       };
33765     }
33766   }
33767
33768   jresult = result;
33769   return jresult;
33770 }
33771
33772
33773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33774   unsigned int jresult ;
33775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33776   bool result;
33777
33778   arg1 = (Dali::Actor *)jarg1;
33779   {
33780     try {
33781       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33782     } catch (std::out_of_range& e) {
33783       {
33784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33785       };
33786     } catch (std::exception& e) {
33787       {
33788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33789       };
33790     } catch (Dali::DaliException e) {
33791       {
33792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33797       };
33798     }
33799   }
33800
33801   jresult = result;
33802   return jresult;
33803 }
33804
33805
33806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33807   unsigned int jresult ;
33808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33809   bool result;
33810
33811   arg1 = (Dali::Actor *)jarg1;
33812   {
33813     try {
33814       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (Dali::DaliException e) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33826       };
33827     } catch (...) {
33828       {
33829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33830       };
33831     }
33832   }
33833
33834   jresult = result;
33835   return jresult;
33836 }
33837
33838
33839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33840   void * jresult ;
33841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33842   Dali::Layer result;
33843
33844   arg1 = (Dali::Actor *)jarg1;
33845   {
33846     try {
33847       result = (arg1)->GetLayer();
33848     } catch (std::out_of_range& e) {
33849       {
33850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33851       };
33852     } catch (std::exception& e) {
33853       {
33854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33855       };
33856     } catch (Dali::DaliException e) {
33857       {
33858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33859       };
33860     } catch (...) {
33861       {
33862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33863       };
33864     }
33865   }
33866
33867   jresult = new Dali::Layer((const Dali::Layer &)result);
33868   return jresult;
33869 }
33870
33871
33872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33874   Dali::Actor arg2 ;
33875   Dali::Actor *argp2 ;
33876
33877   arg1 = (Dali::Actor *)jarg1;
33878   argp2 = (Dali::Actor *)jarg2;
33879   if (!argp2) {
33880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33881     return ;
33882   }
33883   arg2 = *argp2;
33884   {
33885     try {
33886       (arg1)->Add(arg2);
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33894       };
33895     } catch (Dali::DaliException e) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33898       };
33899     } catch (...) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33902       };
33903     }
33904   }
33905
33906 }
33907
33908
33909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33911   Dali::Actor arg2 ;
33912   Dali::Actor *argp2 ;
33913
33914   arg1 = (Dali::Actor *)jarg1;
33915   argp2 = (Dali::Actor *)jarg2;
33916   if (!argp2) {
33917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33918     return ;
33919   }
33920   arg2 = *argp2;
33921   {
33922     try {
33923       (arg1)->Remove(arg2);
33924     } catch (std::out_of_range& e) {
33925       {
33926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33927       };
33928     } catch (std::exception& e) {
33929       {
33930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33931       };
33932     } catch (Dali::DaliException e) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33935       };
33936     } catch (...) {
33937       {
33938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33939       };
33940     }
33941   }
33942
33943 }
33944
33945
33946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33948
33949   arg1 = (Dali::Actor *)jarg1;
33950   {
33951     try {
33952       (arg1)->Unparent();
33953     } catch (std::out_of_range& e) {
33954       {
33955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33956       };
33957     } catch (std::exception& e) {
33958       {
33959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33960       };
33961     } catch (Dali::DaliException e) {
33962       {
33963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33964       };
33965     } catch (...) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33968       };
33969     }
33970   }
33971
33972 }
33973
33974
33975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33976   unsigned int jresult ;
33977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33978   unsigned int result;
33979
33980   arg1 = (Dali::Actor *)jarg1;
33981   {
33982     try {
33983       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33984     } catch (std::out_of_range& e) {
33985       {
33986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33987       };
33988     } catch (std::exception& e) {
33989       {
33990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (Dali::DaliException e) {
33993       {
33994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002
34003   jresult = result;
34004   return jresult;
34005 }
34006
34007
34008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34009   void * jresult ;
34010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34011   unsigned int arg2 ;
34012   Dali::Actor result;
34013
34014   arg1 = (Dali::Actor *)jarg1;
34015   arg2 = (unsigned int)jarg2;
34016   {
34017     try {
34018       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
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::Actor((const Dali::Actor &)result);
34039   return jresult;
34040 }
34041
34042
34043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34044   void * jresult ;
34045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34046   std::string *arg2 = 0 ;
34047   Dali::Actor result;
34048
34049   arg1 = (Dali::Actor *)jarg1;
34050   if (!jarg2) {
34051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34052     return 0;
34053   }
34054   std::string arg2_str(jarg2);
34055   arg2 = &arg2_str;
34056   {
34057     try {
34058       result = (arg1)->FindChildByName((std::string const &)*arg2);
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (Dali::DaliException e) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077
34078   jresult = new Dali::Actor((const Dali::Actor &)result);
34079
34080   //argout typemap for const std::string&
34081
34082   return jresult;
34083 }
34084
34085
34086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34087   void * jresult ;
34088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34089   unsigned int arg2 ;
34090   Dali::Actor result;
34091
34092   arg1 = (Dali::Actor *)jarg1;
34093   arg2 = (unsigned int)jarg2;
34094   {
34095     try {
34096       result = (arg1)->FindChildById(arg2);
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (Dali::DaliException e) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34108       };
34109     } catch (...) {
34110       {
34111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34112       };
34113     }
34114   }
34115
34116   jresult = new Dali::Actor((const Dali::Actor &)result);
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34122   void * jresult ;
34123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34124   Dali::Actor result;
34125
34126   arg1 = (Dali::Actor *)jarg1;
34127   {
34128     try {
34129       result = ((Dali::Actor const *)arg1)->GetParent();
34130     } catch (std::out_of_range& e) {
34131       {
34132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34133       };
34134     } catch (std::exception& e) {
34135       {
34136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34137       };
34138     } catch (Dali::DaliException e) {
34139       {
34140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34141       };
34142     } catch (...) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34145       };
34146     }
34147   }
34148
34149   jresult = new Dali::Actor((const Dali::Actor &)result);
34150   return jresult;
34151 }
34152
34153
34154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34156   Dali::Vector3 *arg2 = 0 ;
34157
34158   arg1 = (Dali::Actor *)jarg1;
34159   arg2 = (Dali::Vector3 *)jarg2;
34160   if (!arg2) {
34161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34162     return ;
34163   }
34164   {
34165     try {
34166       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34167     } catch (std::out_of_range& e) {
34168       {
34169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34170       };
34171     } catch (std::exception& e) {
34172       {
34173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (Dali::DaliException e) {
34176       {
34177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185
34186 }
34187
34188
34189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34190   void * jresult ;
34191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34192   Dali::Vector3 result;
34193
34194   arg1 = (Dali::Actor *)jarg1;
34195   {
34196     try {
34197       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34198     } catch (std::out_of_range& e) {
34199       {
34200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34201       };
34202     } catch (std::exception& e) {
34203       {
34204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34205       };
34206     } catch (Dali::DaliException e) {
34207       {
34208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34209       };
34210     } catch (...) {
34211       {
34212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34213       };
34214     }
34215   }
34216
34217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34218   return jresult;
34219 }
34220
34221
34222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34224   Dali::Vector3 *arg2 = 0 ;
34225
34226   arg1 = (Dali::Actor *)jarg1;
34227   arg2 = (Dali::Vector3 *)jarg2;
34228   if (!arg2) {
34229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34230     return ;
34231   }
34232   {
34233     try {
34234       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34235     } catch (std::out_of_range& e) {
34236       {
34237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34238       };
34239     } catch (std::exception& e) {
34240       {
34241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34242       };
34243     } catch (Dali::DaliException e) {
34244       {
34245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34246       };
34247     } catch (...) {
34248       {
34249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34250       };
34251     }
34252   }
34253
34254 }
34255
34256
34257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34258   void * jresult ;
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   Dali::Vector3 result;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   {
34264     try {
34265       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34266     } catch (std::out_of_range& e) {
34267       {
34268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34269       };
34270     } catch (std::exception& e) {
34271       {
34272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34273       };
34274     } catch (Dali::DaliException e) {
34275       {
34276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34277       };
34278     } catch (...) {
34279       {
34280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34281       };
34282     }
34283   }
34284
34285   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34286   return jresult;
34287 }
34288
34289
34290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   float arg2 ;
34293   float arg3 ;
34294
34295   arg1 = (Dali::Actor *)jarg1;
34296   arg2 = (float)jarg2;
34297   arg3 = (float)jarg3;
34298   {
34299     try {
34300       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34301     } catch (std::out_of_range& e) {
34302       {
34303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34304       };
34305     } catch (std::exception& e) {
34306       {
34307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34308       };
34309     } catch (Dali::DaliException e) {
34310       {
34311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34312       };
34313     } catch (...) {
34314       {
34315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34316       };
34317     }
34318   }
34319
34320 }
34321
34322
34323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34325   float arg2 ;
34326   float arg3 ;
34327   float arg4 ;
34328
34329   arg1 = (Dali::Actor *)jarg1;
34330   arg2 = (float)jarg2;
34331   arg3 = (float)jarg3;
34332   arg4 = (float)jarg4;
34333   {
34334     try {
34335       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34336     } catch (std::out_of_range& e) {
34337       {
34338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34339       };
34340     } catch (std::exception& e) {
34341       {
34342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34343       };
34344     } catch (Dali::DaliException e) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34347       };
34348     } catch (...) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34351       };
34352     }
34353   }
34354
34355 }
34356
34357
34358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34360   Dali::Vector2 *arg2 = 0 ;
34361
34362   arg1 = (Dali::Actor *)jarg1;
34363   arg2 = (Dali::Vector2 *)jarg2;
34364   if (!arg2) {
34365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34366     return ;
34367   }
34368   {
34369     try {
34370       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34371     } catch (std::out_of_range& e) {
34372       {
34373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34374       };
34375     } catch (std::exception& e) {
34376       {
34377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34378       };
34379     } catch (Dali::DaliException e) {
34380       {
34381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34382       };
34383     } catch (...) {
34384       {
34385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34386       };
34387     }
34388   }
34389
34390 }
34391
34392
34393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(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::SIZE, (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_GetTargetSize(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)->GetTargetSize();
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_GetCurrentSize(void * jarg1) {
34462   void * jresult ;
34463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34464   Dali::Vector3 result;
34465
34466   arg1 = (Dali::Actor *)jarg1;
34467   {
34468     try {
34469       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34470     } catch (std::out_of_range& e) {
34471       {
34472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34473       };
34474     } catch (std::exception& e) {
34475       {
34476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34477       };
34478     } catch (Dali::DaliException e) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34485       };
34486     }
34487   }
34488
34489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34490   return jresult;
34491 }
34492
34493
34494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34495   void * jresult ;
34496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34497   Dali::Vector3 result;
34498
34499   arg1 = (Dali::Actor *)jarg1;
34500   {
34501     try {
34502       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34503     } catch (std::out_of_range& e) {
34504       {
34505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34506       };
34507     } catch (std::exception& e) {
34508       {
34509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34510       };
34511     } catch (Dali::DaliException e) {
34512       {
34513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34514       };
34515     } catch (...) {
34516       {
34517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34518       };
34519     }
34520   }
34521
34522   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34523   return jresult;
34524 }
34525
34526
34527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   float arg2 ;
34530   float arg3 ;
34531
34532   arg1 = (Dali::Actor *)jarg1;
34533   arg2 = (float)jarg2;
34534   arg3 = (float)jarg3;
34535   {
34536     try {
34537       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34538     } catch (std::out_of_range& e) {
34539       {
34540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34541       };
34542     } catch (std::exception& e) {
34543       {
34544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34545       };
34546     } catch (Dali::DaliException e) {
34547       {
34548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34549       };
34550     } catch (...) {
34551       {
34552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34553       };
34554     }
34555   }
34556
34557 }
34558
34559
34560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34561   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34562   float arg2 ;
34563   float arg3 ;
34564   float arg4 ;
34565
34566   arg1 = (Dali::Actor *)jarg1;
34567   arg2 = (float)jarg2;
34568   arg3 = (float)jarg3;
34569   arg4 = (float)jarg4;
34570   {
34571     try {
34572       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34573     } catch (std::out_of_range& e) {
34574       {
34575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34576       };
34577     } catch (std::exception& e) {
34578       {
34579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34580       };
34581     } catch (Dali::DaliException e) {
34582       {
34583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34584       };
34585     } catch (...) {
34586       {
34587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34588       };
34589     }
34590   }
34591
34592 }
34593
34594
34595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34596   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34597   Dali::Vector3 *arg2 = 0 ;
34598
34599   arg1 = (Dali::Actor *)jarg1;
34600   arg2 = (Dali::Vector3 *)jarg2;
34601   if (!arg2) {
34602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34603     return ;
34604   }
34605   {
34606     try {
34607       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34608     } catch (std::out_of_range& e) {
34609       {
34610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34611       };
34612     } catch (std::exception& e) {
34613       {
34614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34615       };
34616     } catch (Dali::DaliException e) {
34617       {
34618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34619       };
34620     } catch (...) {
34621       {
34622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34623       };
34624     }
34625   }
34626
34627 }
34628
34629
34630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34631   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34632   float arg2 ;
34633
34634   arg1 = (Dali::Actor *)jarg1;
34635   arg2 = (float)jarg2;
34636   {
34637     try {
34638       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34639     } catch (std::out_of_range& e) {
34640       {
34641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34642       };
34643     } catch (std::exception& e) {
34644       {
34645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34646       };
34647     } catch (Dali::DaliException e) {
34648       {
34649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34650       };
34651     } catch (...) {
34652       {
34653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34654       };
34655     }
34656   }
34657
34658 }
34659
34660
34661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34662   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34663   float arg2 ;
34664
34665   arg1 = (Dali::Actor *)jarg1;
34666   arg2 = (float)jarg2;
34667   {
34668     try {
34669       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34670     } catch (std::out_of_range& e) {
34671       {
34672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34673       };
34674     } catch (std::exception& e) {
34675       {
34676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34677       };
34678     } catch (Dali::DaliException e) {
34679       {
34680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34681       };
34682     } catch (...) {
34683       {
34684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34685       };
34686     }
34687   }
34688
34689 }
34690
34691
34692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34694   float arg2 ;
34695
34696   arg1 = (Dali::Actor *)jarg1;
34697   arg2 = (float)jarg2;
34698   {
34699     try {
34700       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34701     } catch (std::out_of_range& e) {
34702       {
34703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34704       };
34705     } catch (std::exception& e) {
34706       {
34707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34708       };
34709     } catch (Dali::DaliException e) {
34710       {
34711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34712       };
34713     } catch (...) {
34714       {
34715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34716       };
34717     }
34718   }
34719
34720 }
34721
34722
34723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34725   Dali::Vector3 *arg2 = 0 ;
34726
34727   arg1 = (Dali::Actor *)jarg1;
34728   arg2 = (Dali::Vector3 *)jarg2;
34729   if (!arg2) {
34730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34731     return ;
34732   }
34733   {
34734     try {
34735       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34736     } catch (std::out_of_range& e) {
34737       {
34738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34739       };
34740     } catch (std::exception& e) {
34741       {
34742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34743       };
34744     } catch (Dali::DaliException e) {
34745       {
34746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34747       };
34748     } catch (...) {
34749       {
34750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34751       };
34752     }
34753   }
34754
34755 }
34756
34757
34758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34759   void * jresult ;
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   Dali::Vector3 result;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   {
34765     try {
34766       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34767     } catch (std::out_of_range& e) {
34768       {
34769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34770       };
34771     } catch (std::exception& e) {
34772       {
34773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34774       };
34775     } catch (Dali::DaliException e) {
34776       {
34777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34778       };
34779     } catch (...) {
34780       {
34781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34782       };
34783     }
34784   }
34785
34786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34787   return jresult;
34788 }
34789
34790
34791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34792   void * jresult ;
34793   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34794   Dali::Vector3 result;
34795
34796   arg1 = (Dali::Actor *)jarg1;
34797   {
34798     try {
34799       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34800     } catch (std::out_of_range& e) {
34801       {
34802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34803       };
34804     } catch (std::exception& e) {
34805       {
34806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34807       };
34808     } catch (Dali::DaliException e) {
34809       {
34810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34811       };
34812     } catch (...) {
34813       {
34814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34815       };
34816     }
34817   }
34818
34819   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34820   return jresult;
34821 }
34822
34823
34824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34825   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34826   bool arg2 ;
34827
34828   arg1 = (Dali::Actor *)jarg1;
34829   arg2 = jarg2 ? true : false;
34830   {
34831     try {
34832       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34833     } catch (std::out_of_range& e) {
34834       {
34835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34836       };
34837     } catch (std::exception& e) {
34838       {
34839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34840       };
34841     } catch (Dali::DaliException e) {
34842       {
34843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34844       };
34845     } catch (...) {
34846       {
34847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34848       };
34849     }
34850   }
34851
34852 }
34853
34854
34855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34856   unsigned int jresult ;
34857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34858   bool result;
34859
34860   arg1 = (Dali::Actor *)jarg1;
34861   {
34862     try {
34863       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34864     } catch (std::out_of_range& e) {
34865       {
34866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34867       };
34868     } catch (std::exception& e) {
34869       {
34870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34871       };
34872     } catch (Dali::DaliException e) {
34873       {
34874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34875       };
34876     } catch (...) {
34877       {
34878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34879       };
34880     }
34881   }
34882
34883   jresult = result;
34884   return jresult;
34885 }
34886
34887
34888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34890   Dali::Degree *arg2 = 0 ;
34891   Dali::Vector3 *arg3 = 0 ;
34892
34893   arg1 = (Dali::Actor *)jarg1;
34894   arg2 = (Dali::Degree *)jarg2;
34895   if (!arg2) {
34896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34897     return ;
34898   }
34899   arg3 = (Dali::Vector3 *)jarg3;
34900   if (!arg3) {
34901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34902     return ;
34903   }
34904   {
34905     try {
34906       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
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_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34931   Dali::Radian *arg2 = 0 ;
34932   Dali::Vector3 *arg3 = 0 ;
34933
34934   arg1 = (Dali::Actor *)jarg1;
34935   arg2 = (Dali::Radian *)jarg2;
34936   if (!arg2) {
34937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34938     return ;
34939   }
34940   arg3 = (Dali::Vector3 *)jarg3;
34941   if (!arg3) {
34942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34943     return ;
34944   }
34945   {
34946     try {
34947       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34948     } catch (std::out_of_range& e) {
34949       {
34950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34951       };
34952     } catch (std::exception& e) {
34953       {
34954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34955       };
34956     } catch (Dali::DaliException e) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34959       };
34960     } catch (...) {
34961       {
34962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34963       };
34964     }
34965   }
34966
34967 }
34968
34969
34970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34972   Dali::Quaternion *arg2 = 0 ;
34973
34974   arg1 = (Dali::Actor *)jarg1;
34975   arg2 = (Dali::Quaternion *)jarg2;
34976   if (!arg2) {
34977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34978     return ;
34979   }
34980   {
34981     try {
34982       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34983     } catch (std::out_of_range& e) {
34984       {
34985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34986       };
34987     } catch (std::exception& e) {
34988       {
34989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34990       };
34991     } catch (Dali::DaliException e) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34994       };
34995     } catch (...) {
34996       {
34997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34998       };
34999     }
35000   }
35001
35002 }
35003
35004
35005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35006   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35007   Dali::Degree *arg2 = 0 ;
35008   Dali::Vector3 *arg3 = 0 ;
35009
35010   arg1 = (Dali::Actor *)jarg1;
35011   arg2 = (Dali::Degree *)jarg2;
35012   if (!arg2) {
35013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35014     return ;
35015   }
35016   arg3 = (Dali::Vector3 *)jarg3;
35017   if (!arg3) {
35018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35019     return ;
35020   }
35021   {
35022     try {
35023       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35024     } catch (std::out_of_range& e) {
35025       {
35026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35027       };
35028     } catch (std::exception& e) {
35029       {
35030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35031       };
35032     } catch (Dali::DaliException e) {
35033       {
35034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35035       };
35036     } catch (...) {
35037       {
35038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35039       };
35040     }
35041   }
35042
35043 }
35044
35045
35046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35048   Dali::Radian *arg2 = 0 ;
35049   Dali::Vector3 *arg3 = 0 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = (Dali::Radian *)jarg2;
35053   if (!arg2) {
35054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35055     return ;
35056   }
35057   arg3 = (Dali::Vector3 *)jarg3;
35058   if (!arg3) {
35059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35060     return ;
35061   }
35062   {
35063     try {
35064       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (Dali::DaliException e) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35076       };
35077     } catch (...) {
35078       {
35079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35080       };
35081     }
35082   }
35083
35084 }
35085
35086
35087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35089   Dali::Quaternion *arg2 = 0 ;
35090
35091   arg1 = (Dali::Actor *)jarg1;
35092   arg2 = (Dali::Quaternion *)jarg2;
35093   if (!arg2) {
35094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35095     return ;
35096   }
35097   {
35098     try {
35099       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35100     } catch (std::out_of_range& e) {
35101       {
35102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35103       };
35104     } catch (std::exception& e) {
35105       {
35106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35107       };
35108     } catch (Dali::DaliException e) {
35109       {
35110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35111       };
35112     } catch (...) {
35113       {
35114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35115       };
35116     }
35117   }
35118
35119 }
35120
35121
35122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35123   void * jresult ;
35124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35125   Dali::Quaternion result;
35126
35127   arg1 = (Dali::Actor *)jarg1;
35128   {
35129     try {
35130       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35131     } catch (std::out_of_range& e) {
35132       {
35133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35134       };
35135     } catch (std::exception& e) {
35136       {
35137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35138       };
35139     } catch (Dali::DaliException e) {
35140       {
35141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35142       };
35143     } catch (...) {
35144       {
35145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35146       };
35147     }
35148   }
35149
35150   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35151   return jresult;
35152 }
35153
35154
35155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35157   bool arg2 ;
35158
35159   arg1 = (Dali::Actor *)jarg1;
35160   arg2 = jarg2 ? true : false;
35161   {
35162     try {
35163       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35164     } catch (std::out_of_range& e) {
35165       {
35166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35167       };
35168     } catch (std::exception& e) {
35169       {
35170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35171       };
35172     } catch (Dali::DaliException e) {
35173       {
35174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35175       };
35176     } catch (...) {
35177       {
35178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35179       };
35180     }
35181   }
35182
35183 }
35184
35185
35186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35187   unsigned int jresult ;
35188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35189   bool result;
35190
35191   arg1 = (Dali::Actor *)jarg1;
35192   {
35193     try {
35194       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35195     } catch (std::out_of_range& e) {
35196       {
35197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35198       };
35199     } catch (std::exception& e) {
35200       {
35201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35202       };
35203     } catch (Dali::DaliException e) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35206       };
35207     } catch (...) {
35208       {
35209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35210       };
35211     }
35212   }
35213
35214   jresult = result;
35215   return jresult;
35216 }
35217
35218
35219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35220   void * jresult ;
35221   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35222   Dali::Quaternion result;
35223
35224   arg1 = (Dali::Actor *)jarg1;
35225   {
35226     try {
35227       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35228     } catch (std::out_of_range& e) {
35229       {
35230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35231       };
35232     } catch (std::exception& e) {
35233       {
35234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35235       };
35236     } catch (Dali::DaliException e) {
35237       {
35238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35243       };
35244     }
35245   }
35246
35247   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35248   return jresult;
35249 }
35250
35251
35252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35254   float arg2 ;
35255
35256   arg1 = (Dali::Actor *)jarg1;
35257   arg2 = (float)jarg2;
35258   {
35259     try {
35260       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35261     } catch (std::out_of_range& e) {
35262       {
35263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35264       };
35265     } catch (std::exception& e) {
35266       {
35267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35268       };
35269     } catch (Dali::DaliException e) {
35270       {
35271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35272       };
35273     } catch (...) {
35274       {
35275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35276       };
35277     }
35278   }
35279
35280 }
35281
35282
35283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35284   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35285   float arg2 ;
35286   float arg3 ;
35287   float arg4 ;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   arg2 = (float)jarg2;
35291   arg3 = (float)jarg3;
35292   arg4 = (float)jarg4;
35293   {
35294     try {
35295       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35296     } catch (std::out_of_range& e) {
35297       {
35298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35299       };
35300     } catch (std::exception& e) {
35301       {
35302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35303       };
35304     } catch (Dali::DaliException e) {
35305       {
35306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35307       };
35308     } catch (...) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35311       };
35312     }
35313   }
35314
35315 }
35316
35317
35318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35320   Dali::Vector3 *arg2 = 0 ;
35321
35322   arg1 = (Dali::Actor *)jarg1;
35323   arg2 = (Dali::Vector3 *)jarg2;
35324   if (!arg2) {
35325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35326     return ;
35327   }
35328   {
35329     try {
35330       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35331     } catch (std::out_of_range& e) {
35332       {
35333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35334       };
35335     } catch (std::exception& e) {
35336       {
35337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35338       };
35339     } catch (Dali::DaliException e) {
35340       {
35341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35342       };
35343     } catch (...) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35346       };
35347     }
35348   }
35349
35350 }
35351
35352
35353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35355   Dali::Vector3 *arg2 = 0 ;
35356
35357   arg1 = (Dali::Actor *)jarg1;
35358   arg2 = (Dali::Vector3 *)jarg2;
35359   if (!arg2) {
35360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35361     return ;
35362   }
35363   {
35364     try {
35365       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35366     } catch (std::out_of_range& e) {
35367       {
35368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35369       };
35370     } catch (std::exception& e) {
35371       {
35372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35373       };
35374     } catch (Dali::DaliException e) {
35375       {
35376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35377       };
35378     } catch (...) {
35379       {
35380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35381       };
35382     }
35383   }
35384
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35389   void * jresult ;
35390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35391   Dali::Vector3 result;
35392
35393   arg1 = (Dali::Actor *)jarg1;
35394   {
35395     try {
35396       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35397     } catch (std::out_of_range& e) {
35398       {
35399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (std::exception& e) {
35402       {
35403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35404       };
35405     } catch (Dali::DaliException e) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35408       };
35409     } catch (...) {
35410       {
35411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35412       };
35413     }
35414   }
35415
35416   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35422   void * jresult ;
35423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35424   Dali::Vector3 result;
35425
35426   arg1 = (Dali::Actor *)jarg1;
35427   {
35428     try {
35429       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35430     } catch (std::out_of_range& e) {
35431       {
35432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35433       };
35434     } catch (std::exception& e) {
35435       {
35436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35437       };
35438     } catch (Dali::DaliException e) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35441       };
35442     } catch (...) {
35443       {
35444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35445       };
35446     }
35447   }
35448
35449   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35450   return jresult;
35451 }
35452
35453
35454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35456   bool arg2 ;
35457
35458   arg1 = (Dali::Actor *)jarg1;
35459   arg2 = jarg2 ? true : false;
35460   {
35461     try {
35462       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35463     } catch (std::out_of_range& e) {
35464       {
35465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35466       };
35467     } catch (std::exception& e) {
35468       {
35469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35470       };
35471     } catch (Dali::DaliException e) {
35472       {
35473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35474       };
35475     } catch (...) {
35476       {
35477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35478       };
35479     }
35480   }
35481
35482 }
35483
35484
35485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35486   unsigned int jresult ;
35487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35488   bool result;
35489
35490   arg1 = (Dali::Actor *)jarg1;
35491   {
35492     try {
35493       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (Dali::DaliException e) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35505       };
35506     } catch (...) {
35507       {
35508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35509       };
35510     }
35511   }
35512
35513   jresult = result;
35514   return jresult;
35515 }
35516
35517
35518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35519   void * jresult ;
35520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35521   Dali::Matrix result;
35522
35523   arg1 = (Dali::Actor *)jarg1;
35524   {
35525     try {
35526       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35527     } catch (std::out_of_range& e) {
35528       {
35529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35530       };
35531     } catch (std::exception& e) {
35532       {
35533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35534       };
35535     } catch (Dali::DaliException e) {
35536       {
35537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35538       };
35539     } catch (...) {
35540       {
35541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35542       };
35543     }
35544   }
35545
35546   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35547   return jresult;
35548 }
35549
35550
35551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35553   bool arg2 ;
35554
35555   arg1 = (Dali::Actor *)jarg1;
35556   arg2 = jarg2 ? true : false;
35557   {
35558     try {
35559       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35560     } catch (std::out_of_range& e) {
35561       {
35562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35563       };
35564     } catch (std::exception& e) {
35565       {
35566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35567       };
35568     } catch (Dali::DaliException e) {
35569       {
35570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35571       };
35572     } catch (...) {
35573       {
35574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35575       };
35576     }
35577   }
35578
35579 }
35580
35581
35582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35583   unsigned int jresult ;
35584   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35585   bool result;
35586
35587   arg1 = (Dali::Actor *)jarg1;
35588   {
35589     try {
35590       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35591     } catch (std::out_of_range& e) {
35592       {
35593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35594       };
35595     } catch (std::exception& e) {
35596       {
35597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35598       };
35599     } catch (Dali::DaliException e) {
35600       {
35601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35602       };
35603     } catch (...) {
35604       {
35605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35606       };
35607     }
35608   }
35609
35610   jresult = result;
35611   return jresult;
35612 }
35613
35614
35615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35617   float arg2 ;
35618
35619   arg1 = (Dali::Actor *)jarg1;
35620   arg2 = (float)jarg2;
35621   {
35622     try {
35623       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35624     } catch (std::out_of_range& e) {
35625       {
35626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35627       };
35628     } catch (std::exception& e) {
35629       {
35630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35631       };
35632     } catch (Dali::DaliException e) {
35633       {
35634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35635       };
35636     } catch (...) {
35637       {
35638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35639       };
35640     }
35641   }
35642
35643 }
35644
35645
35646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35647   float jresult ;
35648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35649   float result;
35650
35651   arg1 = (Dali::Actor *)jarg1;
35652   {
35653     try {
35654       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35655     } catch (std::out_of_range& e) {
35656       {
35657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35658       };
35659     } catch (std::exception& e) {
35660       {
35661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35662       };
35663     } catch (Dali::DaliException e) {
35664       {
35665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35666       };
35667     } catch (...) {
35668       {
35669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35670       };
35671     }
35672   }
35673
35674   jresult = result;
35675   return jresult;
35676 }
35677
35678
35679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35680   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35681   Dali::Vector4 *arg2 = 0 ;
35682
35683   arg1 = (Dali::Actor *)jarg1;
35684   arg2 = (Dali::Vector4 *)jarg2;
35685   if (!arg2) {
35686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35687     return ;
35688   }
35689   {
35690     try {
35691       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35692     } catch (std::out_of_range& e) {
35693       {
35694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35695       };
35696     } catch (std::exception& e) {
35697       {
35698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35699       };
35700     } catch (Dali::DaliException e) {
35701       {
35702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35703       };
35704     } catch (...) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35707       };
35708     }
35709   }
35710
35711 }
35712
35713
35714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35715   void * jresult ;
35716   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35717   Dali::Vector4 result;
35718
35719   arg1 = (Dali::Actor *)jarg1;
35720   {
35721     try {
35722       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35723     } catch (std::out_of_range& e) {
35724       {
35725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35726       };
35727     } catch (std::exception& e) {
35728       {
35729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35730       };
35731     } catch (Dali::DaliException e) {
35732       {
35733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35738       };
35739     }
35740   }
35741
35742   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35743   return jresult;
35744 }
35745
35746
35747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35748   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35749   Dali::ColorMode arg2 ;
35750
35751   arg1 = (Dali::Actor *)jarg1;
35752   arg2 = (Dali::ColorMode)jarg2;
35753   {
35754     try {
35755       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35756     } catch (std::out_of_range& e) {
35757       {
35758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35759       };
35760     } catch (std::exception& e) {
35761       {
35762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35763       };
35764     } catch (Dali::DaliException e) {
35765       {
35766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35767       };
35768     } catch (...) {
35769       {
35770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35771       };
35772     }
35773   }
35774
35775 }
35776
35777
35778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35779   int jresult ;
35780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35781   Dali::ColorMode result;
35782
35783   arg1 = (Dali::Actor *)jarg1;
35784   {
35785     try {
35786       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35787     } catch (std::out_of_range& e) {
35788       {
35789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35790       };
35791     } catch (std::exception& e) {
35792       {
35793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35794       };
35795     } catch (Dali::DaliException e) {
35796       {
35797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35798       };
35799     } catch (...) {
35800       {
35801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35802       };
35803     }
35804   }
35805
35806   jresult = (int)result;
35807   return jresult;
35808 }
35809
35810
35811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35812   void * jresult ;
35813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35814   Dali::Vector4 result;
35815
35816   arg1 = (Dali::Actor *)jarg1;
35817   {
35818     try {
35819       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35820     } catch (std::out_of_range& e) {
35821       {
35822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35823       };
35824     } catch (std::exception& e) {
35825       {
35826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35827       };
35828     } catch (Dali::DaliException e) {
35829       {
35830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35831       };
35832     } catch (...) {
35833       {
35834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35835       };
35836     }
35837   }
35838
35839   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35840   return jresult;
35841 }
35842
35843
35844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35845   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35846   Dali::DrawMode::Type arg2 ;
35847
35848   arg1 = (Dali::Actor *)jarg1;
35849   arg2 = (Dali::DrawMode::Type)jarg2;
35850   {
35851     try {
35852       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35853     } catch (std::out_of_range& e) {
35854       {
35855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35856       };
35857     } catch (std::exception& e) {
35858       {
35859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35860       };
35861     } catch (Dali::DaliException e) {
35862       {
35863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35864       };
35865     } catch (...) {
35866       {
35867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35868       };
35869     }
35870   }
35871
35872 }
35873
35874
35875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35876   int jresult ;
35877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35878   Dali::DrawMode::Type result;
35879
35880   arg1 = (Dali::Actor *)jarg1;
35881   {
35882     try {
35883       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35884     } catch (std::out_of_range& e) {
35885       {
35886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35887       };
35888     } catch (std::exception& e) {
35889       {
35890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35891       };
35892     } catch (Dali::DaliException e) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35895       };
35896     } catch (...) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35899       };
35900     }
35901   }
35902
35903   jresult = (int)result;
35904   return jresult;
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35910   bool arg2 ;
35911
35912   arg1 = (Dali::Actor *)jarg1;
35913   arg2 = jarg2 ? true : false;
35914   {
35915     try {
35916       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35917     } catch (std::out_of_range& e) {
35918       {
35919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35920       };
35921     } catch (std::exception& e) {
35922       {
35923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35924       };
35925     } catch (Dali::DaliException e) {
35926       {
35927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35928       };
35929     } catch (...) {
35930       {
35931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35932       };
35933     }
35934   }
35935
35936 }
35937
35938
35939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35940   unsigned int jresult ;
35941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35942   bool result;
35943
35944   arg1 = (Dali::Actor *)jarg1;
35945   {
35946     try {
35947       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35948     } catch (std::out_of_range& e) {
35949       {
35950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35951       };
35952     } catch (std::exception& e) {
35953       {
35954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35955       };
35956     } catch (Dali::DaliException e) {
35957       {
35958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35959       };
35960     } catch (...) {
35961       {
35962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35963       };
35964     }
35965   }
35966
35967   jresult = result;
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35973   unsigned int jresult ;
35974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35975   float *arg2 = 0 ;
35976   float *arg3 = 0 ;
35977   float arg4 ;
35978   float arg5 ;
35979   bool result;
35980
35981   arg1 = (Dali::Actor *)jarg1;
35982   arg2 = (float *)jarg2;
35983   arg3 = (float *)jarg3;
35984   arg4 = (float)jarg4;
35985   arg5 = (float)jarg5;
35986   {
35987     try {
35988       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36004       };
36005     }
36006   }
36007
36008   jresult = result;
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36015   bool arg2 ;
36016
36017   arg1 = (Dali::Actor *)jarg1;
36018   arg2 = jarg2 ? true : false;
36019   {
36020     try {
36021       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36022     } catch (std::out_of_range& e) {
36023       {
36024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36025       };
36026     } catch (std::exception& e) {
36027       {
36028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36029       };
36030     } catch (Dali::DaliException e) {
36031       {
36032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36033       };
36034     } catch (...) {
36035       {
36036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36037       };
36038     }
36039   }
36040
36041 }
36042
36043
36044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36045   unsigned int jresult ;
36046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36047   bool result;
36048
36049   arg1 = (Dali::Actor *)jarg1;
36050   {
36051     try {
36052       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36053     } catch (std::out_of_range& e) {
36054       {
36055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (std::exception& e) {
36058       {
36059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (Dali::DaliException e) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071
36072   jresult = result;
36073   return jresult;
36074 }
36075
36076
36077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36079   bool arg2 ;
36080
36081   arg1 = (Dali::Actor *)jarg1;
36082   arg2 = jarg2 ? true : false;
36083   {
36084     try {
36085       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36086     } catch (std::out_of_range& e) {
36087       {
36088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36089       };
36090     } catch (std::exception& e) {
36091       {
36092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36093       };
36094     } catch (Dali::DaliException e) {
36095       {
36096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36097       };
36098     } catch (...) {
36099       {
36100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36101       };
36102     }
36103   }
36104
36105 }
36106
36107
36108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36109   unsigned int jresult ;
36110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36111   bool result;
36112
36113   arg1 = (Dali::Actor *)jarg1;
36114   {
36115     try {
36116       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (Dali::DaliException e) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36128       };
36129     } catch (...) {
36130       {
36131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36132       };
36133     }
36134   }
36135
36136   jresult = result;
36137   return jresult;
36138 }
36139
36140
36141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36142   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36143   Dali::ResizePolicy::Type arg2 ;
36144   Dali::Dimension::Type arg3 ;
36145
36146   arg1 = (Dali::Actor *)jarg1;
36147   arg2 = (Dali::ResizePolicy::Type)jarg2;
36148   arg3 = (Dali::Dimension::Type)jarg3;
36149   {
36150     try {
36151       (arg1)->SetResizePolicy(arg2,arg3);
36152     } catch (std::out_of_range& e) {
36153       {
36154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36155       };
36156     } catch (std::exception& e) {
36157       {
36158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36159       };
36160     } catch (Dali::DaliException e) {
36161       {
36162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36163       };
36164     } catch (...) {
36165       {
36166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36167       };
36168     }
36169   }
36170
36171 }
36172
36173
36174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36175   int jresult ;
36176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36177   Dali::Dimension::Type arg2 ;
36178   Dali::ResizePolicy::Type result;
36179
36180   arg1 = (Dali::Actor *)jarg1;
36181   arg2 = (Dali::Dimension::Type)jarg2;
36182   {
36183     try {
36184       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36185     } catch (std::out_of_range& e) {
36186       {
36187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36188       };
36189     } catch (std::exception& e) {
36190       {
36191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36192       };
36193     } catch (Dali::DaliException e) {
36194       {
36195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36196       };
36197     } catch (...) {
36198       {
36199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36200       };
36201     }
36202   }
36203
36204   jresult = (int)result;
36205   return jresult;
36206 }
36207
36208
36209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36210   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36211   Dali::SizeScalePolicy::Type arg2 ;
36212
36213   arg1 = (Dali::Actor *)jarg1;
36214   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36215   {
36216     try {
36217       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36218     } catch (std::out_of_range& e) {
36219       {
36220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36221       };
36222     } catch (std::exception& e) {
36223       {
36224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36225       };
36226     } catch (Dali::DaliException e) {
36227       {
36228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36229       };
36230     } catch (...) {
36231       {
36232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36233       };
36234     }
36235   }
36236
36237 }
36238
36239
36240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36241   int jresult ;
36242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36243   Dali::SizeScalePolicy::Type result;
36244
36245   arg1 = (Dali::Actor *)jarg1;
36246   {
36247     try {
36248       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36249     } catch (std::out_of_range& e) {
36250       {
36251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36252       };
36253     } catch (std::exception& e) {
36254       {
36255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36256       };
36257     } catch (Dali::DaliException e) {
36258       {
36259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36260       };
36261     } catch (...) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36264       };
36265     }
36266   }
36267
36268   jresult = (int)result;
36269   return jresult;
36270 }
36271
36272
36273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36274   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36275   Dali::Vector3 *arg2 = 0 ;
36276
36277   arg1 = (Dali::Actor *)jarg1;
36278   arg2 = (Dali::Vector3 *)jarg2;
36279   if (!arg2) {
36280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36281     return ;
36282   }
36283   {
36284     try {
36285       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36286     } catch (std::out_of_range& e) {
36287       {
36288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36289       };
36290     } catch (std::exception& e) {
36291       {
36292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36293       };
36294     } catch (Dali::DaliException e) {
36295       {
36296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36297       };
36298     } catch (...) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36301       };
36302     }
36303   }
36304
36305 }
36306
36307
36308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36309   void * jresult ;
36310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36311   Dali::Vector3 result;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   {
36315     try {
36316       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36317     } catch (std::out_of_range& e) {
36318       {
36319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36320       };
36321     } catch (std::exception& e) {
36322       {
36323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36324       };
36325     } catch (Dali::DaliException e) {
36326       {
36327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36328       };
36329     } catch (...) {
36330       {
36331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36332       };
36333     }
36334   }
36335
36336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36337   return jresult;
36338 }
36339
36340
36341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36342   float jresult ;
36343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36344   float arg2 ;
36345   float result;
36346
36347   arg1 = (Dali::Actor *)jarg1;
36348   arg2 = (float)jarg2;
36349   {
36350     try {
36351       result = (float)(arg1)->GetHeightForWidth(arg2);
36352     } catch (std::out_of_range& e) {
36353       {
36354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36355       };
36356     } catch (std::exception& e) {
36357       {
36358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36359       };
36360     } catch (Dali::DaliException e) {
36361       {
36362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36363       };
36364     } catch (...) {
36365       {
36366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36367       };
36368     }
36369   }
36370
36371   jresult = result;
36372   return jresult;
36373 }
36374
36375
36376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36377   float jresult ;
36378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36379   float arg2 ;
36380   float result;
36381
36382   arg1 = (Dali::Actor *)jarg1;
36383   arg2 = (float)jarg2;
36384   {
36385     try {
36386       result = (float)(arg1)->GetWidthForHeight(arg2);
36387     } catch (std::out_of_range& e) {
36388       {
36389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36390       };
36391     } catch (std::exception& e) {
36392       {
36393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (Dali::DaliException e) {
36396       {
36397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405
36406   jresult = result;
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36412   float jresult ;
36413   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36414   Dali::Dimension::Type arg2 ;
36415   float result;
36416
36417   arg1 = (Dali::Actor *)jarg1;
36418   arg2 = (Dali::Dimension::Type)jarg2;
36419   {
36420     try {
36421       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36422     } catch (std::out_of_range& e) {
36423       {
36424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36425       };
36426     } catch (std::exception& e) {
36427       {
36428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36429       };
36430     } catch (Dali::DaliException e) {
36431       {
36432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36433       };
36434     } catch (...) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36437       };
36438     }
36439   }
36440
36441   jresult = result;
36442   return jresult;
36443 }
36444
36445
36446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   Dali::Padding *arg2 = 0 ;
36449
36450   arg1 = (Dali::Actor *)jarg1;
36451   arg2 = (Dali::Padding *)jarg2;
36452   if (!arg2) {
36453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36454     return ;
36455   }
36456   {
36457     try {
36458       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36459     } catch (std::out_of_range& e) {
36460       {
36461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36462       };
36463     } catch (std::exception& e) {
36464       {
36465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36466       };
36467     } catch (Dali::DaliException e) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36474       };
36475     }
36476   }
36477
36478 }
36479
36480
36481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36483   Dali::Padding *arg2 = 0 ;
36484
36485   arg1 = (Dali::Actor *)jarg1;
36486   arg2 = (Dali::Padding *)jarg2;
36487   if (!arg2) {
36488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36489     return ;
36490   }
36491   {
36492     try {
36493       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36494     } catch (std::out_of_range& e) {
36495       {
36496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36497       };
36498     } catch (std::exception& e) {
36499       {
36500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36501       };
36502     } catch (Dali::DaliException e) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36505       };
36506     } catch (...) {
36507       {
36508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36509       };
36510     }
36511   }
36512
36513 }
36514
36515
36516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36518   Dali::Vector2 *arg2 = 0 ;
36519
36520   arg1 = (Dali::Actor *)jarg1;
36521   arg2 = (Dali::Vector2 *)jarg2;
36522   if (!arg2) {
36523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36524     return ;
36525   }
36526   {
36527     try {
36528       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36529     } catch (std::out_of_range& e) {
36530       {
36531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36532       };
36533     } catch (std::exception& e) {
36534       {
36535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36536       };
36537     } catch (Dali::DaliException e) {
36538       {
36539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36544       };
36545     }
36546   }
36547
36548 }
36549
36550
36551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36552   void * jresult ;
36553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36554   Dali::Vector2 result;
36555
36556   arg1 = (Dali::Actor *)jarg1;
36557   {
36558     try {
36559       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36560     } catch (std::out_of_range& e) {
36561       {
36562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (std::exception& e) {
36565       {
36566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36567       };
36568     } catch (Dali::DaliException e) {
36569       {
36570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36571       };
36572     } catch (...) {
36573       {
36574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36575       };
36576     }
36577   }
36578
36579   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36580   return jresult;
36581 }
36582
36583
36584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36586   Dali::Vector2 *arg2 = 0 ;
36587
36588   arg1 = (Dali::Actor *)jarg1;
36589   arg2 = (Dali::Vector2 *)jarg2;
36590   if (!arg2) {
36591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36592     return ;
36593   }
36594   {
36595     try {
36596       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36597     } catch (std::out_of_range& e) {
36598       {
36599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36600       };
36601     } catch (std::exception& e) {
36602       {
36603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (Dali::DaliException e) {
36606       {
36607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36608       };
36609     } catch (...) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36612       };
36613     }
36614   }
36615
36616 }
36617
36618
36619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36620   void * jresult ;
36621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36622   Dali::Vector2 result;
36623
36624   arg1 = (Dali::Actor *)jarg1;
36625   {
36626     try {
36627       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36628     } catch (std::out_of_range& e) {
36629       {
36630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36631       };
36632     } catch (std::exception& e) {
36633       {
36634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36635       };
36636     } catch (Dali::DaliException e) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36639       };
36640     } catch (...) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36643       };
36644     }
36645   }
36646
36647   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36648   return jresult;
36649 }
36650
36651
36652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36653   int jresult ;
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   int result;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   {
36659     try {
36660       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36661       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36662     } catch (std::out_of_range& e) {
36663       {
36664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36665       };
36666     } catch (std::exception& e) {
36667       {
36668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36669       };
36670     } catch (Dali::DaliException e) {
36671       {
36672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36673       };
36674     } catch (...) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36677       };
36678     }
36679   }
36680
36681   jresult = result;
36682   return jresult;
36683 }
36684
36685
36686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36687   unsigned int jresult ;
36688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36689   Dali::Renderer *arg2 = 0 ;
36690   unsigned int result;
36691
36692   arg1 = (Dali::Actor *)jarg1;
36693   arg2 = (Dali::Renderer *)jarg2;
36694   if (!arg2) {
36695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36696     return 0;
36697   }
36698   {
36699     try {
36700       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36701     } catch (std::out_of_range& e) {
36702       {
36703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (std::exception& e) {
36706       {
36707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (Dali::DaliException e) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36726   unsigned int jresult ;
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   unsigned int result;
36729
36730   arg1 = (Dali::Actor *)jarg1;
36731   {
36732     try {
36733       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36734     } catch (std::out_of_range& e) {
36735       {
36736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (std::exception& e) {
36739       {
36740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36741       };
36742     } catch (Dali::DaliException e) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36745       };
36746     } catch (...) {
36747       {
36748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36749       };
36750     }
36751   }
36752
36753   jresult = result;
36754   return jresult;
36755 }
36756
36757
36758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36759   void * jresult ;
36760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36761   unsigned int arg2 ;
36762   Dali::Renderer result;
36763
36764   arg1 = (Dali::Actor *)jarg1;
36765   arg2 = (unsigned int)jarg2;
36766   {
36767     try {
36768       result = (arg1)->GetRendererAt(arg2);
36769     } catch (std::out_of_range& e) {
36770       {
36771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36772       };
36773     } catch (std::exception& e) {
36774       {
36775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (Dali::DaliException e) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36784       };
36785     }
36786   }
36787
36788   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36789   return jresult;
36790 }
36791
36792
36793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36795   Dali::Renderer *arg2 = 0 ;
36796
36797   arg1 = (Dali::Actor *)jarg1;
36798   arg2 = (Dali::Renderer *)jarg2;
36799   if (!arg2) {
36800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36801     return ;
36802   }
36803   {
36804     try {
36805       (arg1)->RemoveRenderer(*arg2);
36806     } catch (std::out_of_range& e) {
36807       {
36808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36809       };
36810     } catch (std::exception& e) {
36811       {
36812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36813       };
36814     } catch (Dali::DaliException e) {
36815       {
36816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36817       };
36818     } catch (...) {
36819       {
36820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36821       };
36822     }
36823   }
36824
36825 }
36826
36827
36828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36830   unsigned int arg2 ;
36831
36832   arg1 = (Dali::Actor *)jarg1;
36833   arg2 = (unsigned int)jarg2;
36834   {
36835     try {
36836       (arg1)->RemoveRenderer(arg2);
36837     } catch (std::out_of_range& e) {
36838       {
36839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36840       };
36841     } catch (std::exception& e) {
36842       {
36843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36844       };
36845     } catch (Dali::DaliException e) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36852       };
36853     }
36854   }
36855
36856 }
36857
36858
36859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36860   void * jresult ;
36861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36862   Dali::Actor::TouchDataSignalType *result = 0 ;
36863
36864   arg1 = (Dali::Actor *)jarg1;
36865   {
36866     try {
36867       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36868     } catch (std::out_of_range& e) {
36869       {
36870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (std::exception& e) {
36873       {
36874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (Dali::DaliException e) {
36877       {
36878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36879       };
36880     } catch (...) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36883       };
36884     }
36885   }
36886
36887   jresult = (void *)result;
36888   return jresult;
36889 }
36890
36891
36892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36893   void * jresult ;
36894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36895   Dali::Actor::HoverSignalType *result = 0 ;
36896
36897   arg1 = (Dali::Actor *)jarg1;
36898   {
36899     try {
36900       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36901     } catch (std::out_of_range& e) {
36902       {
36903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (std::exception& e) {
36906       {
36907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (Dali::DaliException e) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36912       };
36913     } catch (...) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36916       };
36917     }
36918   }
36919
36920   jresult = (void *)result;
36921   return jresult;
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36926   void * jresult ;
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   Dali::Actor::WheelEventSignalType *result = 0 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   {
36932     try {
36933       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36934     } catch (std::out_of_range& e) {
36935       {
36936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36937       };
36938     } catch (std::exception& e) {
36939       {
36940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (Dali::DaliException e) {
36943       {
36944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952
36953   jresult = (void *)result;
36954   return jresult;
36955 }
36956
36957
36958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36959   void * jresult ;
36960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36961   Dali::Actor::OnSceneSignalType *result = 0 ;
36962
36963   arg1 = (Dali::Actor *)jarg1;
36964   {
36965     try {
36966       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36967     } catch (std::out_of_range& e) {
36968       {
36969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36970       };
36971     } catch (std::exception& e) {
36972       {
36973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36974       };
36975     } catch (Dali::DaliException e) {
36976       {
36977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36978       };
36979     } catch (...) {
36980       {
36981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36982       };
36983     }
36984   }
36985
36986   jresult = (void *)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36992   void * jresult ;
36993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36994   Dali::Actor::OffSceneSignalType *result = 0 ;
36995
36996   arg1 = (Dali::Actor *)jarg1;
36997   {
36998     try {
36999       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
37000     } catch (std::out_of_range& e) {
37001       {
37002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37003       };
37004     } catch (std::exception& e) {
37005       {
37006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37007       };
37008     } catch (Dali::DaliException e) {
37009       {
37010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37011       };
37012     } catch (...) {
37013       {
37014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37015       };
37016     }
37017   }
37018
37019   jresult = (void *)result;
37020   return jresult;
37021 }
37022
37023
37024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37025   void * jresult ;
37026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37027   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37028
37029   arg1 = (Dali::Actor *)jarg1;
37030   {
37031     try {
37032       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (Dali::DaliException e) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37044       };
37045     } catch (...) {
37046       {
37047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37048       };
37049     }
37050   }
37051
37052   jresult = (void *)result;
37053   return jresult;
37054 }
37055
37056
37057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37058   Dali::Actor *arg1 = 0 ;
37059
37060   arg1 = (Dali::Actor *)jarg1;
37061   if (!arg1) {
37062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37063     return ;
37064   }
37065   {
37066     try {
37067       Dali::UnparentAndReset(*arg1);
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37083       };
37084     }
37085   }
37086
37087 }
37088
37089
37090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37091   int jresult ;
37092   int result;
37093
37094   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37095   jresult = (int)result;
37096   return jresult;
37097 }
37098
37099
37100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37101   int jresult ;
37102   int result;
37103
37104   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37105   jresult = (int)result;
37106   return jresult;
37107 }
37108
37109
37110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37111   int jresult ;
37112   int result;
37113
37114   result = (int)Dali::Layer::Property::BEHAVIOR;
37115   jresult = (int)result;
37116   return jresult;
37117 }
37118
37119
37120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37121   void * jresult ;
37122   Dali::Layer::Property *result = 0 ;
37123
37124   {
37125     try {
37126       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37127     } catch (std::out_of_range& e) {
37128       {
37129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37130       };
37131     } catch (std::exception& e) {
37132       {
37133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37134       };
37135     } catch (Dali::DaliException e) {
37136       {
37137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37138       };
37139     } catch (...) {
37140       {
37141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37142       };
37143     }
37144   }
37145
37146   jresult = (void *)result;
37147   return jresult;
37148 }
37149
37150
37151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37152   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37153
37154   arg1 = (Dali::Layer::Property *)jarg1;
37155   {
37156     try {
37157       delete arg1;
37158     } catch (std::out_of_range& e) {
37159       {
37160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37161       };
37162     } catch (std::exception& e) {
37163       {
37164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37165       };
37166     } catch (Dali::DaliException e) {
37167       {
37168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37169       };
37170     } catch (...) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37173       };
37174     }
37175   }
37176
37177 }
37178
37179
37180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37181   void * jresult ;
37182   Dali::Layer *result = 0 ;
37183
37184   {
37185     try {
37186       result = (Dali::Layer *)new Dali::Layer();
37187     } catch (std::out_of_range& e) {
37188       {
37189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37190       };
37191     } catch (std::exception& e) {
37192       {
37193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37194       };
37195     } catch (Dali::DaliException e) {
37196       {
37197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37198       };
37199     } catch (...) {
37200       {
37201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37202       };
37203     }
37204   }
37205
37206   jresult = (void *)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37212   void * jresult ;
37213   Dali::Layer result;
37214
37215   {
37216     try {
37217       result = Dali::Layer::New();
37218     } catch (std::out_of_range& e) {
37219       {
37220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37221       };
37222     } catch (std::exception& e) {
37223       {
37224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37225       };
37226     } catch (Dali::DaliException e) {
37227       {
37228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37229       };
37230     } catch (...) {
37231       {
37232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37233       };
37234     }
37235   }
37236
37237   jresult = new Dali::Layer((const Dali::Layer &)result);
37238   return jresult;
37239 }
37240
37241
37242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37243   void * jresult ;
37244   Dali::BaseHandle arg1 ;
37245   Dali::BaseHandle *argp1 ;
37246   Dali::Layer result;
37247
37248   argp1 = (Dali::BaseHandle *)jarg1;
37249   if (!argp1) {
37250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37251     return 0;
37252   }
37253   arg1 = *argp1;
37254   {
37255     try {
37256       result = Dali::Layer::DownCast(arg1);
37257     } catch (std::out_of_range& e) {
37258       {
37259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37260       };
37261     } catch (std::exception& e) {
37262       {
37263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37264       };
37265     } catch (Dali::DaliException e) {
37266       {
37267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37268       };
37269     } catch (...) {
37270       {
37271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37272       };
37273     }
37274   }
37275
37276   jresult = new Dali::Layer((const Dali::Layer &)result);
37277   return jresult;
37278 }
37279
37280
37281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37282   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37283
37284   arg1 = (Dali::Layer *)jarg1;
37285   {
37286     try {
37287       delete arg1;
37288     } catch (std::out_of_range& e) {
37289       {
37290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37291       };
37292     } catch (std::exception& e) {
37293       {
37294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37295       };
37296     } catch (Dali::DaliException e) {
37297       {
37298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37299       };
37300     } catch (...) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37303       };
37304     }
37305   }
37306
37307 }
37308
37309
37310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37311   void * jresult ;
37312   Dali::Layer *arg1 = 0 ;
37313   Dali::Layer *result = 0 ;
37314
37315   arg1 = (Dali::Layer *)jarg1;
37316   if (!arg1) {
37317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37318     return 0;
37319   }
37320   {
37321     try {
37322       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37323     } catch (std::out_of_range& e) {
37324       {
37325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (std::exception& e) {
37328       {
37329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37330       };
37331     } catch (Dali::DaliException e) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37334       };
37335     } catch (...) {
37336       {
37337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37338       };
37339     }
37340   }
37341
37342   jresult = (void *)result;
37343   return jresult;
37344 }
37345
37346
37347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37348   void * jresult ;
37349   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37350   Dali::Layer *arg2 = 0 ;
37351   Dali::Layer *result = 0 ;
37352
37353   arg1 = (Dali::Layer *)jarg1;
37354   arg2 = (Dali::Layer *)jarg2;
37355   if (!arg2) {
37356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37357     return 0;
37358   }
37359   {
37360     try {
37361       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37362     } catch (std::out_of_range& e) {
37363       {
37364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37365       };
37366     } catch (std::exception& e) {
37367       {
37368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37369       };
37370     } catch (Dali::DaliException e) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37377       };
37378     }
37379   }
37380
37381   jresult = (void *)result;
37382   return jresult;
37383 }
37384
37385
37386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37387   unsigned int jresult ;
37388   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37389   unsigned int result;
37390
37391   arg1 = (Dali::Layer *)jarg1;
37392   {
37393     try {
37394       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37395     } catch (std::out_of_range& e) {
37396       {
37397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37398       };
37399     } catch (std::exception& e) {
37400       {
37401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (Dali::DaliException e) {
37404       {
37405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37406       };
37407     } catch (...) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37410       };
37411     }
37412   }
37413
37414   jresult = result;
37415   return jresult;
37416 }
37417
37418
37419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37420   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37421
37422   arg1 = (Dali::Layer *)jarg1;
37423   {
37424     try {
37425       (arg1)->Raise();
37426     } catch (std::out_of_range& e) {
37427       {
37428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37429       };
37430     } catch (std::exception& e) {
37431       {
37432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37433       };
37434     } catch (Dali::DaliException e) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37437       };
37438     } catch (...) {
37439       {
37440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37441       };
37442     }
37443   }
37444
37445 }
37446
37447
37448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37449   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37450
37451   arg1 = (Dali::Layer *)jarg1;
37452   {
37453     try {
37454       (arg1)->Lower();
37455     } catch (std::out_of_range& e) {
37456       {
37457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37458       };
37459     } catch (std::exception& e) {
37460       {
37461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37462       };
37463     } catch (Dali::DaliException e) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37466       };
37467     } catch (...) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37470       };
37471     }
37472   }
37473
37474 }
37475
37476
37477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37478   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37479   Dali::Layer arg2 ;
37480   Dali::Layer *argp2 ;
37481
37482   arg1 = (Dali::Layer *)jarg1;
37483   argp2 = (Dali::Layer *)jarg2;
37484   if (!argp2) {
37485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37486     return ;
37487   }
37488   arg2 = *argp2;
37489   {
37490     try {
37491       (arg1)->RaiseAbove(arg2);
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_Layer_LowerBelow(void * jarg1, void * jarg2) {
37515   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37516   Dali::Layer arg2 ;
37517   Dali::Layer *argp2 ;
37518
37519   arg1 = (Dali::Layer *)jarg1;
37520   argp2 = (Dali::Layer *)jarg2;
37521   if (!argp2) {
37522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37523     return ;
37524   }
37525   arg2 = *argp2;
37526   {
37527     try {
37528       (arg1)->LowerBelow(arg2);
37529     } catch (std::out_of_range& e) {
37530       {
37531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37532       };
37533     } catch (std::exception& e) {
37534       {
37535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37536       };
37537     } catch (Dali::DaliException e) {
37538       {
37539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37540       };
37541     } catch (...) {
37542       {
37543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37544       };
37545     }
37546   }
37547
37548 }
37549
37550
37551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37552   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37553
37554   arg1 = (Dali::Layer *)jarg1;
37555   {
37556     try {
37557       (arg1)->RaiseToTop();
37558     } catch (std::out_of_range& e) {
37559       {
37560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37561       };
37562     } catch (std::exception& e) {
37563       {
37564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37565       };
37566     } catch (Dali::DaliException e) {
37567       {
37568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37569       };
37570     } catch (...) {
37571       {
37572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37573       };
37574     }
37575   }
37576
37577 }
37578
37579
37580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37581   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37582
37583   arg1 = (Dali::Layer *)jarg1;
37584   {
37585     try {
37586       (arg1)->LowerToBottom();
37587     } catch (std::out_of_range& e) {
37588       {
37589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37590       };
37591     } catch (std::exception& e) {
37592       {
37593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37594       };
37595     } catch (Dali::DaliException e) {
37596       {
37597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37598       };
37599     } catch (...) {
37600       {
37601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37602       };
37603     }
37604   }
37605
37606 }
37607
37608
37609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37610   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37611   Dali::Layer arg2 ;
37612   Dali::Layer *argp2 ;
37613
37614   arg1 = (Dali::Layer *)jarg1;
37615   argp2 = (Dali::Layer *)jarg2;
37616   if (!argp2) {
37617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37618     return ;
37619   }
37620   arg2 = *argp2;
37621   {
37622     try {
37623       (arg1)->MoveAbove(arg2);
37624     } catch (std::out_of_range& e) {
37625       {
37626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37627       };
37628     } catch (std::exception& e) {
37629       {
37630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (Dali::DaliException e) {
37633       {
37634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37635       };
37636     } catch (...) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37639       };
37640     }
37641   }
37642
37643 }
37644
37645
37646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37647   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37648   Dali::Layer arg2 ;
37649   Dali::Layer *argp2 ;
37650
37651   arg1 = (Dali::Layer *)jarg1;
37652   argp2 = (Dali::Layer *)jarg2;
37653   if (!argp2) {
37654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37655     return ;
37656   }
37657   arg2 = *argp2;
37658   {
37659     try {
37660       (arg1)->MoveBelow(arg2);
37661     } catch (std::out_of_range& e) {
37662       {
37663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37664       };
37665     } catch (std::exception& e) {
37666       {
37667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37668       };
37669     } catch (Dali::DaliException e) {
37670       {
37671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37672       };
37673     } catch (...) {
37674       {
37675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37676       };
37677     }
37678   }
37679
37680 }
37681
37682
37683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37684   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37685   Dali::Layer::Behavior arg2 ;
37686
37687   arg1 = (Dali::Layer *)jarg1;
37688   arg2 = (Dali::Layer::Behavior)jarg2;
37689   {
37690     try {
37691       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37692     } catch (std::out_of_range& e) {
37693       {
37694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37695       };
37696     } catch (std::exception& e) {
37697       {
37698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37699       };
37700     } catch (Dali::DaliException e) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37703       };
37704     } catch (...) {
37705       {
37706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37707       };
37708     }
37709   }
37710
37711 }
37712
37713
37714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37715   int jresult ;
37716   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37717   Dali::Layer::Behavior result;
37718
37719   arg1 = (Dali::Layer *)jarg1;
37720   {
37721     try {
37722       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37723     } catch (std::out_of_range& e) {
37724       {
37725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37726       };
37727     } catch (std::exception& e) {
37728       {
37729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37730       };
37731     } catch (Dali::DaliException e) {
37732       {
37733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37734       };
37735     } catch (...) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37738       };
37739     }
37740   }
37741
37742   jresult = (int)result;
37743   return jresult;
37744 }
37745
37746
37747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37748   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37749   bool arg2 ;
37750
37751   arg1 = (Dali::Layer *)jarg1;
37752   arg2 = jarg2 ? true : false;
37753   {
37754     try {
37755       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37756     } catch (std::out_of_range& e) {
37757       {
37758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37759       };
37760     } catch (std::exception& e) {
37761       {
37762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37763       };
37764     } catch (Dali::DaliException e) {
37765       {
37766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37767       };
37768     } catch (...) {
37769       {
37770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37771       };
37772     }
37773   }
37774
37775 }
37776
37777
37778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37779   unsigned int jresult ;
37780   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37781   bool result;
37782
37783   arg1 = (Dali::Layer *)jarg1;
37784   {
37785     try {
37786       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37787     } catch (std::out_of_range& e) {
37788       {
37789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37790       };
37791     } catch (std::exception& e) {
37792       {
37793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37794       };
37795     } catch (Dali::DaliException e) {
37796       {
37797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37798       };
37799     } catch (...) {
37800       {
37801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37802       };
37803     }
37804   }
37805
37806   jresult = result;
37807   return jresult;
37808 }
37809
37810
37811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37812   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37813   int arg2 ;
37814   int arg3 ;
37815   int arg4 ;
37816   int arg5 ;
37817
37818   arg1 = (Dali::Layer *)jarg1;
37819   arg2 = (int)jarg2;
37820   arg3 = (int)jarg3;
37821   arg4 = (int)jarg4;
37822   arg5 = (int)jarg5;
37823   {
37824     try {
37825       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37826     } catch (std::out_of_range& e) {
37827       {
37828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37829       };
37830     } catch (std::exception& e) {
37831       {
37832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37833       };
37834     } catch (Dali::DaliException e) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37837       };
37838     } catch (...) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37841       };
37842     }
37843   }
37844
37845 }
37846
37847
37848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37849   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37850   Dali::ClippingBox arg2 ;
37851   Dali::ClippingBox *argp2 ;
37852
37853   arg1 = (Dali::Layer *)jarg1;
37854   argp2 = (Dali::ClippingBox *)jarg2;
37855   if (!argp2) {
37856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37857     return ;
37858   }
37859   arg2 = *argp2;
37860   {
37861     try {
37862       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37863     } catch (std::out_of_range& e) {
37864       {
37865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37866       };
37867     } catch (std::exception& e) {
37868       {
37869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37870       };
37871     } catch (Dali::DaliException e) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37874       };
37875     } catch (...) {
37876       {
37877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37878       };
37879     }
37880   }
37881
37882 }
37883
37884
37885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37886   void * jresult ;
37887   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37888   Dali::ClippingBox result;
37889
37890   arg1 = (Dali::Layer *)jarg1;
37891   {
37892     try {
37893       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37901       };
37902     } catch (Dali::DaliException e) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37905       };
37906     } catch (...) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37909       };
37910     }
37911   }
37912
37913   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37914   return jresult;
37915 }
37916
37917
37918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37919   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37920   bool arg2 ;
37921
37922   arg1 = (Dali::Layer *)jarg1;
37923   arg2 = jarg2 ? true : false;
37924   {
37925     try {
37926       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37942       };
37943     }
37944   }
37945
37946 }
37947
37948
37949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37950   unsigned int jresult ;
37951   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37952   bool result;
37953
37954   arg1 = (Dali::Layer *)jarg1;
37955   {
37956     try {
37957       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37958     } catch (std::out_of_range& e) {
37959       {
37960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37961       };
37962     } catch (std::exception& e) {
37963       {
37964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37965       };
37966     } catch (Dali::DaliException e) {
37967       {
37968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37969       };
37970     } catch (...) {
37971       {
37972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37973       };
37974     }
37975   }
37976
37977   jresult = result;
37978   return jresult;
37979 }
37980
37981
37982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37983   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37984   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37985
37986   arg1 = (Dali::Layer *)jarg1;
37987   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37988   {
37989     try {
37990       (arg1)->SetSortFunction(arg2);
37991     } catch (std::out_of_range& e) {
37992       {
37993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37994       };
37995     } catch (std::exception& e) {
37996       {
37997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37998       };
37999     } catch (Dali::DaliException e) {
38000       {
38001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38002       };
38003     } catch (...) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38006       };
38007     }
38008   }
38009
38010 }
38011
38012
38013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38014   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38015   bool arg2 ;
38016
38017   arg1 = (Dali::Layer *)jarg1;
38018   arg2 = jarg2 ? true : false;
38019   {
38020     try {
38021       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38022     } catch (std::out_of_range& e) {
38023       {
38024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38025       };
38026     } catch (std::exception& e) {
38027       {
38028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38029       };
38030     } catch (Dali::DaliException e) {
38031       {
38032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38033       };
38034     } catch (...) {
38035       {
38036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38037       };
38038     }
38039   }
38040
38041 }
38042
38043
38044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38045   unsigned int jresult ;
38046   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38047   bool result;
38048
38049   arg1 = (Dali::Layer *)jarg1;
38050   {
38051     try {
38052       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38053     } catch (std::out_of_range& e) {
38054       {
38055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38056       };
38057     } catch (std::exception& e) {
38058       {
38059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38060       };
38061     } catch (Dali::DaliException e) {
38062       {
38063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38064       };
38065     } catch (...) {
38066       {
38067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38068       };
38069     }
38070   }
38071
38072   jresult = result;
38073   return jresult;
38074 }
38075
38076
38077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38078   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38079   bool arg2 ;
38080
38081   arg1 = (Dali::Layer *)jarg1;
38082   arg2 = jarg2 ? true : false;
38083   {
38084     try {
38085       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38086     } catch (std::out_of_range& e) {
38087       {
38088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38089       };
38090     } catch (std::exception& e) {
38091       {
38092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38093       };
38094     } catch (Dali::DaliException e) {
38095       {
38096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38097       };
38098     } catch (...) {
38099       {
38100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38101       };
38102     }
38103   }
38104
38105 }
38106
38107
38108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38109   unsigned int jresult ;
38110   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38111   bool result;
38112
38113   arg1 = (Dali::Layer *)jarg1;
38114   {
38115     try {
38116       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38117     } catch (std::out_of_range& e) {
38118       {
38119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38120       };
38121     } catch (std::exception& e) {
38122       {
38123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38124       };
38125     } catch (Dali::DaliException e) {
38126       {
38127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38128       };
38129     } catch (...) {
38130       {
38131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38132       };
38133     }
38134   }
38135
38136   jresult = result;
38137   return jresult;
38138 }
38139
38140
38141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38142   void * jresult ;
38143   Dali::Stage result;
38144
38145   {
38146     try {
38147       result = Dali::Stage::GetCurrent();
38148     } catch (std::out_of_range& e) {
38149       {
38150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38151       };
38152     } catch (std::exception& e) {
38153       {
38154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38155       };
38156     } catch (Dali::DaliException e) {
38157       {
38158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38159       };
38160     } catch (...) {
38161       {
38162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38163       };
38164     }
38165   }
38166
38167   jresult = new Dali::Stage((const Dali::Stage &)result);
38168   return jresult;
38169 }
38170
38171
38172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38173   unsigned int jresult ;
38174   bool result;
38175
38176   {
38177     try {
38178       result = (bool)Dali::Stage::IsInstalled();
38179     } catch (std::out_of_range& e) {
38180       {
38181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38182       };
38183     } catch (std::exception& e) {
38184       {
38185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38186       };
38187     } catch (Dali::DaliException e) {
38188       {
38189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38190       };
38191     } catch (...) {
38192       {
38193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38194       };
38195     }
38196   }
38197
38198   jresult = result;
38199   return jresult;
38200 }
38201
38202
38203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38204   void * jresult ;
38205   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38206   Dali::Vector2 result;
38207
38208   arg1 = (Dali::Stage *)jarg1;
38209   {
38210     try {
38211       result = ((Dali::Stage const *)arg1)->GetDpi();
38212     } catch (std::out_of_range& e) {
38213       {
38214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38215       };
38216     } catch (std::exception& e) {
38217       {
38218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38219       };
38220     } catch (Dali::DaliException e) {
38221       {
38222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38223       };
38224     } catch (...) {
38225       {
38226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38227       };
38228     }
38229   }
38230
38231   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38232   return jresult;
38233 }
38234
38235
38236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38237   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38238   float arg2 ;
38239
38240   arg1 = (Dali::Stage *)jarg1;
38241   arg2 = (float)jarg2;
38242   {
38243     try {
38244       (arg1)->KeepRendering(arg2);
38245     } catch (std::out_of_range& e) {
38246       {
38247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38248       };
38249     } catch (std::exception& e) {
38250       {
38251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38252       };
38253     } catch (Dali::DaliException e) {
38254       {
38255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38256       };
38257     } catch (...) {
38258       {
38259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38260       };
38261     }
38262   }
38263
38264 }
38265
38266
38267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38268   void * jresult ;
38269   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38270   Dali::Stage::KeyEventSignalType *result = 0 ;
38271
38272   arg1 = (Dali::Stage *)jarg1;
38273   {
38274     try {
38275       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38276     } catch (std::out_of_range& e) {
38277       {
38278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38279       };
38280     } catch (std::exception& e) {
38281       {
38282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38283       };
38284     } catch (Dali::DaliException e) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38287       };
38288     } catch (...) {
38289       {
38290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38291       };
38292     }
38293   }
38294
38295   jresult = (void *)result;
38296   return jresult;
38297 }
38298
38299
38300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38301   void * jresult ;
38302   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38303   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38304
38305   arg1 = (Dali::Stage *)jarg1;
38306   {
38307     try {
38308       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38309     } catch (std::out_of_range& e) {
38310       {
38311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38312       };
38313     } catch (std::exception& e) {
38314       {
38315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38316       };
38317     } catch (Dali::DaliException e) {
38318       {
38319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38320       };
38321     } catch (...) {
38322       {
38323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38324       };
38325     }
38326   }
38327
38328   jresult = (void *)result;
38329   return jresult;
38330 }
38331
38332
38333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38334   void * jresult ;
38335   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38336   Dali::Stage::TouchSignalType *result = 0 ;
38337
38338   arg1 = (Dali::Stage *)jarg1;
38339   {
38340     try {
38341       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38342     } catch (std::out_of_range& e) {
38343       {
38344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38345       };
38346     } catch (std::exception& e) {
38347       {
38348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38349       };
38350     } catch (Dali::DaliException e) {
38351       {
38352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38357       };
38358     }
38359   }
38360
38361   jresult = (void *)result;
38362   return jresult;
38363 }
38364
38365
38366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38367   void * jresult ;
38368   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38369   Dali::Stage::WheelEventSignalType *result = 0 ;
38370
38371   arg1 = (Dali::Stage *)jarg1;
38372   {
38373     try {
38374       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38375     } catch (std::out_of_range& e) {
38376       {
38377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38378       };
38379     } catch (std::exception& e) {
38380       {
38381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38382       };
38383     } catch (Dali::DaliException e) {
38384       {
38385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38386       };
38387     } catch (...) {
38388       {
38389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38390       };
38391     }
38392   }
38393
38394   jresult = (void *)result;
38395   return jresult;
38396 }
38397
38398
38399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38400   void * jresult ;
38401   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38402   Dali::Stage::ContextStatusSignal *result = 0 ;
38403
38404   arg1 = (Dali::Stage *)jarg1;
38405   {
38406     try {
38407       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38408     } catch (std::out_of_range& e) {
38409       {
38410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38411       };
38412     } catch (std::exception& e) {
38413       {
38414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38415       };
38416     } catch (Dali::DaliException e) {
38417       {
38418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38419       };
38420     } catch (...) {
38421       {
38422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38423       };
38424     }
38425   }
38426
38427   jresult = (void *)result;
38428   return jresult;
38429 }
38430
38431
38432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38433   void * jresult ;
38434   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38435   Dali::Stage::ContextStatusSignal *result = 0 ;
38436
38437   arg1 = (Dali::Stage *)jarg1;
38438   {
38439     try {
38440       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38441     } catch (std::out_of_range& e) {
38442       {
38443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38444       };
38445     } catch (std::exception& e) {
38446       {
38447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38448       };
38449     } catch (Dali::DaliException e) {
38450       {
38451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38452       };
38453     } catch (...) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38456       };
38457     }
38458   }
38459
38460   jresult = (void *)result;
38461   return jresult;
38462 }
38463
38464
38465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38466   void * jresult ;
38467   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38468   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38469
38470   arg1 = (Dali::Stage *)jarg1;
38471   {
38472     try {
38473       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38474     } catch (std::out_of_range& e) {
38475       {
38476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38477       };
38478     } catch (std::exception& e) {
38479       {
38480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38481       };
38482     } catch (Dali::DaliException e) {
38483       {
38484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38485       };
38486     } catch (...) {
38487       {
38488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38489       };
38490     }
38491   }
38492
38493   jresult = (void *)result;
38494   return jresult;
38495 }
38496
38497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38498   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38499   Dali::DevelStage::Rendering arg2 ;
38500
38501   arg1 = (Dali::Stage *)jarg1;
38502   arg2 = (Dali::DevelStage::Rendering)jarg2;
38503   {
38504     try {
38505       DevelStage::SetRenderingBehavior(*arg1,arg2);
38506     } catch (std::out_of_range& e) {
38507       {
38508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38509       };
38510     } catch (std::exception& e) {
38511       {
38512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38513       };
38514     } catch (Dali::DaliException e) {
38515       {
38516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38517       };
38518     } catch (...) {
38519       {
38520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38521       };
38522     }
38523   }
38524
38525 }
38526
38527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38528
38529   int jresult ;
38530   int result ;
38531   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38532
38533   arg1 = (Dali::Stage *)jarg1;
38534   {
38535     try {
38536       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38537     } catch (std::out_of_range& e) {
38538       {
38539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38540       };
38541     } catch (std::exception& e) {
38542       {
38543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (Dali::DaliException e) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555
38556   jresult = result;
38557   return jresult;
38558 }
38559
38560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38561   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38562
38563   arg1 = (Dali::RelayoutContainer *)jarg1;
38564   {
38565     try {
38566       delete arg1;
38567     } catch (std::out_of_range& e) {
38568       {
38569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38570       };
38571     } catch (std::exception& e) {
38572       {
38573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38574       };
38575     } catch (Dali::DaliException e) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38578       };
38579     } catch (...) {
38580       {
38581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38582       };
38583     }
38584   }
38585
38586 }
38587
38588
38589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38590   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38591   Dali::Actor *arg2 = 0 ;
38592   Dali::Vector2 *arg3 = 0 ;
38593
38594   arg1 = (Dali::RelayoutContainer *)jarg1;
38595   arg2 = (Dali::Actor *)jarg2;
38596   if (!arg2) {
38597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38598     return ;
38599   }
38600   arg3 = (Dali::Vector2 *)jarg3;
38601   if (!arg3) {
38602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38603     return ;
38604   }
38605   {
38606     try {
38607       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38608     } catch (std::out_of_range& e) {
38609       {
38610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38611       };
38612     } catch (std::exception& e) {
38613       {
38614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38615       };
38616     } catch (Dali::DaliException e) {
38617       {
38618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38619       };
38620     } catch (...) {
38621       {
38622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38623       };
38624     }
38625   }
38626
38627 }
38628
38629
38630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38631   void * jresult ;
38632   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38633   Dali::CustomActor result;
38634
38635   arg1 = (Dali::CustomActorImpl *)jarg1;
38636   {
38637     try {
38638       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38639     } catch (std::out_of_range& e) {
38640       {
38641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38642       };
38643     } catch (std::exception& e) {
38644       {
38645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38646       };
38647     } catch (Dali::DaliException e) {
38648       {
38649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38650       };
38651     } catch (...) {
38652       {
38653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38654       };
38655     }
38656   }
38657
38658   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38659   return jresult;
38660 }
38661
38662
38663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38664   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38665   int arg2 ;
38666
38667   arg1 = (Dali::CustomActorImpl *)jarg1;
38668   arg2 = (int)jarg2;
38669   {
38670     try {
38671       (arg1)->OnSceneConnection(arg2);
38672     } catch (std::out_of_range& e) {
38673       {
38674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38675       };
38676     } catch (std::exception& e) {
38677       {
38678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38679       };
38680     } catch (Dali::DaliException e) {
38681       {
38682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38683       };
38684     } catch (...) {
38685       {
38686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38687       };
38688     }
38689   }
38690
38691 }
38692
38693
38694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38695   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38696
38697   arg1 = (Dali::CustomActorImpl *)jarg1;
38698   {
38699     try {
38700       (arg1)->OnSceneDisconnection();
38701     } catch (std::out_of_range& e) {
38702       {
38703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38704       };
38705     } catch (std::exception& e) {
38706       {
38707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38708       };
38709     } catch (Dali::DaliException e) {
38710       {
38711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38712       };
38713     } catch (...) {
38714       {
38715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38716       };
38717     }
38718   }
38719
38720 }
38721
38722
38723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38724   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38725   Dali::Actor *arg2 = 0 ;
38726
38727   arg1 = (Dali::CustomActorImpl *)jarg1;
38728   arg2 = (Dali::Actor *)jarg2;
38729   if (!arg2) {
38730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38731     return ;
38732   }
38733   {
38734     try {
38735       (arg1)->OnChildAdd(*arg2);
38736     } catch (std::out_of_range& e) {
38737       {
38738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38739       };
38740     } catch (std::exception& e) {
38741       {
38742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38743       };
38744     } catch (Dali::DaliException e) {
38745       {
38746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38747       };
38748     } catch (...) {
38749       {
38750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38751       };
38752     }
38753   }
38754
38755 }
38756
38757
38758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38759   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38760   Dali::Actor *arg2 = 0 ;
38761
38762   arg1 = (Dali::CustomActorImpl *)jarg1;
38763   arg2 = (Dali::Actor *)jarg2;
38764   if (!arg2) {
38765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38766     return ;
38767   }
38768   {
38769     try {
38770       (arg1)->OnChildRemove(*arg2);
38771     } catch (std::out_of_range& e) {
38772       {
38773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38774       };
38775     } catch (std::exception& e) {
38776       {
38777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38778       };
38779     } catch (Dali::DaliException e) {
38780       {
38781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38782       };
38783     } catch (...) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38786       };
38787     }
38788   }
38789
38790 }
38791
38792
38793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38794   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38795   Dali::Property::Index arg2 ;
38796   Dali::Property::Value arg3 ;
38797   Dali::Property::Value *argp3 ;
38798
38799   arg1 = (Dali::CustomActorImpl *)jarg1;
38800   arg2 = (Dali::Property::Index)jarg2;
38801   argp3 = (Dali::Property::Value *)jarg3;
38802   if (!argp3) {
38803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38804     return ;
38805   }
38806   arg3 = *argp3;
38807   {
38808     try {
38809       (arg1)->OnPropertySet(arg2,arg3);
38810     } catch (std::out_of_range& e) {
38811       {
38812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38813       };
38814     } catch (std::exception& e) {
38815       {
38816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38817       };
38818     } catch (Dali::DaliException e) {
38819       {
38820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38821       };
38822     } catch (...) {
38823       {
38824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38825       };
38826     }
38827   }
38828
38829 }
38830
38831
38832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38834   Dali::Vector3 *arg2 = 0 ;
38835
38836   arg1 = (Dali::CustomActorImpl *)jarg1;
38837   arg2 = (Dali::Vector3 *)jarg2;
38838   if (!arg2) {
38839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38840     return ;
38841   }
38842   {
38843     try {
38844       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38845     } catch (std::out_of_range& e) {
38846       {
38847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38848       };
38849     } catch (std::exception& e) {
38850       {
38851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38852       };
38853     } catch (Dali::DaliException e) {
38854       {
38855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38856       };
38857     } catch (...) {
38858       {
38859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38860       };
38861     }
38862   }
38863
38864 }
38865
38866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38867   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38868   Dali::Animation *arg2 = 0 ;
38869   Dali::Vector3 *arg3 = 0 ;
38870
38871   arg1 = (Dali::CustomActorImpl *)jarg1;
38872   arg2 = (Dali::Animation *)jarg2;
38873   if (!arg2) {
38874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38875     return ;
38876   }
38877   arg3 = (Dali::Vector3 *)jarg3;
38878   if (!arg3) {
38879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38880     return ;
38881   }
38882   {
38883     try {
38884       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38885     } catch (std::out_of_range& e) {
38886       {
38887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38888       };
38889     } catch (std::exception& e) {
38890       {
38891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38892       };
38893     } catch (Dali::DaliException e) {
38894       {
38895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38896       };
38897     } catch (...) {
38898       {
38899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38900       };
38901     }
38902   }
38903
38904 }
38905
38906
38907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
38908   unsigned int jresult ;
38909   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38910   Dali::TouchEvent *arg2 = 0 ;
38911   bool result;
38912
38913   arg1 = (Dali::CustomActorImpl *)jarg1;
38914   arg2 = (Dali::TouchEvent *)jarg2;
38915   if (!arg2) {
38916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
38917     return 0;
38918   }
38919   {
38920     try {
38921       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
38922     } catch (std::out_of_range& e) {
38923       {
38924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38925       };
38926     } catch (std::exception& e) {
38927       {
38928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (Dali::DaliException e) {
38931       {
38932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38933       };
38934     } catch (...) {
38935       {
38936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38937       };
38938     }
38939   }
38940
38941   jresult = result;
38942   return jresult;
38943 }
38944
38945
38946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38947   unsigned int jresult ;
38948   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38949   Dali::HoverEvent *arg2 = 0 ;
38950   bool result;
38951
38952   arg1 = (Dali::CustomActorImpl *)jarg1;
38953   arg2 = (Dali::HoverEvent *)jarg2;
38954   if (!arg2) {
38955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38956     return 0;
38957   }
38958   {
38959     try {
38960       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38961     } catch (std::out_of_range& e) {
38962       {
38963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38964       };
38965     } catch (std::exception& e) {
38966       {
38967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38968       };
38969     } catch (Dali::DaliException e) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38972       };
38973     } catch (...) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38976       };
38977     }
38978   }
38979
38980   jresult = result;
38981   return jresult;
38982 }
38983
38984
38985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38986   unsigned int jresult ;
38987   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38988   Dali::KeyEvent *arg2 = 0 ;
38989   bool result;
38990
38991   arg1 = (Dali::CustomActorImpl *)jarg1;
38992   arg2 = (Dali::KeyEvent *)jarg2;
38993   if (!arg2) {
38994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38995     return 0;
38996   }
38997   {
38998     try {
38999       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39000     } catch (std::out_of_range& e) {
39001       {
39002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39003       };
39004     } catch (std::exception& e) {
39005       {
39006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39007       };
39008     } catch (Dali::DaliException e) {
39009       {
39010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39011       };
39012     } catch (...) {
39013       {
39014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39015       };
39016     }
39017   }
39018
39019   jresult = result;
39020   return jresult;
39021 }
39022
39023
39024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39025   unsigned int jresult ;
39026   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39027   Dali::WheelEvent *arg2 = 0 ;
39028   bool result;
39029
39030   arg1 = (Dali::CustomActorImpl *)jarg1;
39031   arg2 = (Dali::WheelEvent *)jarg2;
39032   if (!arg2) {
39033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39034     return 0;
39035   }
39036   {
39037     try {
39038       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39039     } catch (std::out_of_range& e) {
39040       {
39041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39042       };
39043     } catch (std::exception& e) {
39044       {
39045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39046       };
39047     } catch (Dali::DaliException e) {
39048       {
39049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39050       };
39051     } catch (...) {
39052       {
39053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39054       };
39055     }
39056   }
39057
39058   jresult = result;
39059   return jresult;
39060 }
39061
39062
39063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39064   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39065   Dali::Vector2 *arg2 = 0 ;
39066   Dali::RelayoutContainer *arg3 = 0 ;
39067
39068   arg1 = (Dali::CustomActorImpl *)jarg1;
39069   arg2 = (Dali::Vector2 *)jarg2;
39070   if (!arg2) {
39071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39072     return ;
39073   }
39074   arg3 = (Dali::RelayoutContainer *)jarg3;
39075   if (!arg3) {
39076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39077     return ;
39078   }
39079   {
39080     try {
39081       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39082     } catch (std::out_of_range& e) {
39083       {
39084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39085       };
39086     } catch (std::exception& e) {
39087       {
39088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39089       };
39090     } catch (Dali::DaliException e) {
39091       {
39092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39093       };
39094     } catch (...) {
39095       {
39096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39097       };
39098     }
39099   }
39100
39101 }
39102
39103
39104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39105   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39106   Dali::ResizePolicy::Type arg2 ;
39107   Dali::Dimension::Type arg3 ;
39108
39109   arg1 = (Dali::CustomActorImpl *)jarg1;
39110   arg2 = (Dali::ResizePolicy::Type)jarg2;
39111   arg3 = (Dali::Dimension::Type)jarg3;
39112   {
39113     try {
39114       (arg1)->OnSetResizePolicy(arg2,arg3);
39115     } catch (std::out_of_range& e) {
39116       {
39117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39118       };
39119     } catch (std::exception& e) {
39120       {
39121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39122       };
39123     } catch (Dali::DaliException e) {
39124       {
39125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39126       };
39127     } catch (...) {
39128       {
39129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39130       };
39131     }
39132   }
39133
39134 }
39135
39136
39137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39138   void * jresult ;
39139   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39140   Dali::Vector3 result;
39141
39142   arg1 = (Dali::CustomActorImpl *)jarg1;
39143   {
39144     try {
39145       result = (arg1)->GetNaturalSize();
39146     } catch (std::out_of_range& e) {
39147       {
39148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39149       };
39150     } catch (std::exception& e) {
39151       {
39152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39153       };
39154     } catch (Dali::DaliException e) {
39155       {
39156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39157       };
39158     } catch (...) {
39159       {
39160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39161       };
39162     }
39163   }
39164
39165   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39166   return jresult;
39167 }
39168
39169
39170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39171   float jresult ;
39172   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39173   Dali::Actor *arg2 = 0 ;
39174   Dali::Dimension::Type arg3 ;
39175   float result;
39176
39177   arg1 = (Dali::CustomActorImpl *)jarg1;
39178   arg2 = (Dali::Actor *)jarg2;
39179   if (!arg2) {
39180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39181     return 0;
39182   }
39183   arg3 = (Dali::Dimension::Type)jarg3;
39184   {
39185     try {
39186       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39187     } catch (std::out_of_range& e) {
39188       {
39189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39190       };
39191     } catch (std::exception& e) {
39192       {
39193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39194       };
39195     } catch (Dali::DaliException e) {
39196       {
39197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39198       };
39199     } catch (...) {
39200       {
39201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39202       };
39203     }
39204   }
39205
39206   jresult = result;
39207   return jresult;
39208 }
39209
39210
39211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39212   float jresult ;
39213   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39214   float arg2 ;
39215   float result;
39216
39217   arg1 = (Dali::CustomActorImpl *)jarg1;
39218   arg2 = (float)jarg2;
39219   {
39220     try {
39221       result = (float)(arg1)->GetHeightForWidth(arg2);
39222     } catch (std::out_of_range& e) {
39223       {
39224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39225       };
39226     } catch (std::exception& e) {
39227       {
39228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39229       };
39230     } catch (Dali::DaliException e) {
39231       {
39232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39233       };
39234     } catch (...) {
39235       {
39236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39237       };
39238     }
39239   }
39240
39241   jresult = result;
39242   return jresult;
39243 }
39244
39245
39246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39247   float jresult ;
39248   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39249   float arg2 ;
39250   float result;
39251
39252   arg1 = (Dali::CustomActorImpl *)jarg1;
39253   arg2 = (float)jarg2;
39254   {
39255     try {
39256       result = (float)(arg1)->GetWidthForHeight(arg2);
39257     } catch (std::out_of_range& e) {
39258       {
39259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39260       };
39261     } catch (std::exception& e) {
39262       {
39263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39264       };
39265     } catch (Dali::DaliException e) {
39266       {
39267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39268       };
39269     } catch (...) {
39270       {
39271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39272       };
39273     }
39274   }
39275
39276   jresult = result;
39277   return jresult;
39278 }
39279
39280
39281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39282   unsigned int jresult ;
39283   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39284   Dali::Dimension::Type arg2 ;
39285   bool result;
39286
39287   arg1 = (Dali::CustomActorImpl *)jarg1;
39288   arg2 = (Dali::Dimension::Type)jarg2;
39289   {
39290     try {
39291       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39292     } catch (std::out_of_range& e) {
39293       {
39294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39295       };
39296     } catch (std::exception& e) {
39297       {
39298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39299       };
39300     } catch (Dali::DaliException e) {
39301       {
39302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39303       };
39304     } catch (...) {
39305       {
39306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39307       };
39308     }
39309   }
39310
39311   jresult = result;
39312   return jresult;
39313 }
39314
39315
39316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39317   unsigned int jresult ;
39318   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39319   bool result;
39320
39321   arg1 = (Dali::CustomActorImpl *)jarg1;
39322   {
39323     try {
39324       result = (bool)(arg1)->RelayoutDependentOnChildren();
39325     } catch (std::out_of_range& e) {
39326       {
39327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39328       };
39329     } catch (std::exception& e) {
39330       {
39331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39332       };
39333     } catch (Dali::DaliException e) {
39334       {
39335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39336       };
39337     } catch (...) {
39338       {
39339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39340       };
39341     }
39342   }
39343
39344   jresult = result;
39345   return jresult;
39346 }
39347
39348
39349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39350   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39351   Dali::Dimension::Type arg2 ;
39352
39353   arg1 = (Dali::CustomActorImpl *)jarg1;
39354   arg2 = (Dali::Dimension::Type)jarg2;
39355   {
39356     try {
39357       (arg1)->OnCalculateRelayoutSize(arg2);
39358     } catch (std::out_of_range& e) {
39359       {
39360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39361       };
39362     } catch (std::exception& e) {
39363       {
39364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39365       };
39366     } catch (Dali::DaliException e) {
39367       {
39368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39369       };
39370     } catch (...) {
39371       {
39372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39373       };
39374     }
39375   }
39376
39377 }
39378
39379
39380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39381   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39382   float arg2 ;
39383   Dali::Dimension::Type arg3 ;
39384
39385   arg1 = (Dali::CustomActorImpl *)jarg1;
39386   arg2 = (float)jarg2;
39387   arg3 = (Dali::Dimension::Type)jarg3;
39388   {
39389     try {
39390       (arg1)->OnLayoutNegotiated(arg2,arg3);
39391     } catch (std::out_of_range& e) {
39392       {
39393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39394       };
39395     } catch (std::exception& e) {
39396       {
39397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39398       };
39399     } catch (Dali::DaliException e) {
39400       {
39401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39402       };
39403     } catch (...) {
39404       {
39405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39406       };
39407     }
39408   }
39409
39410 }
39411
39412
39413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39414   unsigned int jresult ;
39415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39416   bool result;
39417
39418   arg1 = (Dali::CustomActorImpl *)jarg1;
39419   {
39420     try {
39421       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39422     } catch (std::out_of_range& e) {
39423       {
39424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39425       };
39426     } catch (std::exception& e) {
39427       {
39428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39429       };
39430     } catch (Dali::DaliException e) {
39431       {
39432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39433       };
39434     } catch (...) {
39435       {
39436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39437       };
39438     }
39439   }
39440
39441   jresult = result;
39442   return jresult;
39443 }
39444
39445
39446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39447   unsigned int jresult ;
39448   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39449   bool result;
39450
39451   arg1 = (Dali::CustomActorImpl *)jarg1;
39452   {
39453     try {
39454       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39455     } catch (std::out_of_range& e) {
39456       {
39457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39458       };
39459     } catch (std::exception& e) {
39460       {
39461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39462       };
39463     } catch (Dali::DaliException e) {
39464       {
39465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39466       };
39467     } catch (...) {
39468       {
39469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39470       };
39471     }
39472   }
39473
39474   jresult = result;
39475   return jresult;
39476 }
39477
39478
39479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39480   unsigned int jresult ;
39481   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39482   bool result;
39483
39484   arg1 = (Dali::CustomActorImpl *)jarg1;
39485   {
39486     try {
39487       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39488     } catch (std::out_of_range& e) {
39489       {
39490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39491       };
39492     } catch (std::exception& e) {
39493       {
39494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39495       };
39496     } catch (Dali::DaliException e) {
39497       {
39498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39499       };
39500     } catch (...) {
39501       {
39502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39503       };
39504     }
39505   }
39506
39507   jresult = result;
39508   return jresult;
39509 }
39510
39511
39512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39513   unsigned int jresult ;
39514   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39515   bool result;
39516
39517   arg1 = (Dali::CustomActorImpl *)jarg1;
39518   {
39519     try {
39520       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39521     } catch (std::out_of_range& e) {
39522       {
39523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39524       };
39525     } catch (std::exception& e) {
39526       {
39527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39528       };
39529     } catch (Dali::DaliException e) {
39530       {
39531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39532       };
39533     } catch (...) {
39534       {
39535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39536       };
39537     }
39538   }
39539
39540   jresult = result;
39541   return jresult;
39542 }
39543
39544
39545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39546   void * jresult ;
39547   Dali::CustomActor *result = 0 ;
39548
39549   {
39550     try {
39551       result = (Dali::CustomActor *)new Dali::CustomActor();
39552     } catch (std::out_of_range& e) {
39553       {
39554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39555       };
39556     } catch (std::exception& e) {
39557       {
39558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39559       };
39560     } catch (Dali::DaliException e) {
39561       {
39562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39563       };
39564     } catch (...) {
39565       {
39566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39567       };
39568     }
39569   }
39570
39571   jresult = (void *)result;
39572   return jresult;
39573 }
39574
39575
39576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39577   void * jresult ;
39578   Dali::BaseHandle arg1 ;
39579   Dali::BaseHandle *argp1 ;
39580   Dali::CustomActor result;
39581
39582   argp1 = (Dali::BaseHandle *)jarg1;
39583   if (!argp1) {
39584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39585     return 0;
39586   }
39587   arg1 = *argp1;
39588   {
39589     try {
39590       result = Dali::CustomActor::DownCast(arg1);
39591     } catch (std::out_of_range& e) {
39592       {
39593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39594       };
39595     } catch (std::exception& e) {
39596       {
39597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39598       };
39599     } catch (Dali::DaliException e) {
39600       {
39601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39602       };
39603     } catch (...) {
39604       {
39605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39606       };
39607     }
39608   }
39609
39610   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39611   return jresult;
39612 }
39613
39614
39615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39616   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39617
39618   arg1 = (Dali::CustomActor *)jarg1;
39619   {
39620     try {
39621       delete arg1;
39622     } catch (std::out_of_range& e) {
39623       {
39624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39625       };
39626     } catch (std::exception& e) {
39627       {
39628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39629       };
39630     } catch (Dali::DaliException e) {
39631       {
39632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39633       };
39634     } catch (...) {
39635       {
39636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39637       };
39638     }
39639   }
39640
39641 }
39642
39643
39644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39645   void * jresult ;
39646   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39647   Dali::CustomActorImpl *result = 0 ;
39648
39649   arg1 = (Dali::CustomActor *)jarg1;
39650   {
39651     try {
39652       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39653     } catch (std::out_of_range& e) {
39654       {
39655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (std::exception& e) {
39658       {
39659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39660       };
39661     } catch (Dali::DaliException e) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39664       };
39665     } catch (...) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39668       };
39669     }
39670   }
39671
39672   jresult = (void *)result;
39673   return jresult;
39674 }
39675
39676
39677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39678   void * jresult ;
39679   Dali::CustomActorImpl *arg1 = 0 ;
39680   Dali::CustomActor *result = 0 ;
39681
39682   arg1 = (Dali::CustomActorImpl *)jarg1;
39683   if (!arg1) {
39684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39685     return 0;
39686   }
39687   {
39688     try {
39689       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39690     } catch (std::out_of_range& e) {
39691       {
39692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39693       };
39694     } catch (std::exception& e) {
39695       {
39696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39697       };
39698     } catch (Dali::DaliException e) {
39699       {
39700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39701       };
39702     } catch (...) {
39703       {
39704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39705       };
39706     }
39707   }
39708
39709   jresult = (void *)result;
39710   return jresult;
39711 }
39712
39713
39714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39715   void * jresult ;
39716   Dali::CustomActor *arg1 = 0 ;
39717   Dali::CustomActor *result = 0 ;
39718
39719   arg1 = (Dali::CustomActor *)jarg1;
39720   if (!arg1) {
39721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39722     return 0;
39723   }
39724   {
39725     try {
39726       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39727     } catch (std::out_of_range& e) {
39728       {
39729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39730       };
39731     } catch (std::exception& e) {
39732       {
39733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39734       };
39735     } catch (Dali::DaliException e) {
39736       {
39737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39738       };
39739     } catch (...) {
39740       {
39741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39742       };
39743     }
39744   }
39745
39746   jresult = (void *)result;
39747   return jresult;
39748 }
39749
39750
39751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39752   void * jresult ;
39753   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39754   Dali::CustomActor *arg2 = 0 ;
39755   Dali::CustomActor *result = 0 ;
39756
39757   arg1 = (Dali::CustomActor *)jarg1;
39758   arg2 = (Dali::CustomActor *)jarg2;
39759   if (!arg2) {
39760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39761     return 0;
39762   }
39763   {
39764     try {
39765       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39766     } catch (std::out_of_range& e) {
39767       {
39768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39769       };
39770     } catch (std::exception& e) {
39771       {
39772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39773       };
39774     } catch (Dali::DaliException e) {
39775       {
39776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39781       };
39782     }
39783   }
39784
39785   jresult = (void *)result;
39786   return jresult;
39787 }
39788
39789
39790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39791   int jresult ;
39792   int result;
39793
39794   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39795   jresult = (int)result;
39796   return jresult;
39797 }
39798
39799
39800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39801   int jresult ;
39802   int result;
39803
39804   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39805   jresult = (int)result;
39806   return jresult;
39807 }
39808
39809
39810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39811   int jresult ;
39812   int result;
39813
39814   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39815   jresult = (int)result;
39816   return jresult;
39817 }
39818
39819
39820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39821   int jresult ;
39822   int result;
39823
39824   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39825   jresult = (int)result;
39826   return jresult;
39827 }
39828
39829
39830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39831   int jresult ;
39832   int result;
39833
39834   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39835   jresult = (int)result;
39836   return jresult;
39837 }
39838
39839
39840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39841   int jresult ;
39842   int result;
39843
39844   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39845   jresult = (int)result;
39846   return jresult;
39847 }
39848
39849
39850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39851   int jresult ;
39852   int result;
39853
39854   result = (int)Dali::PanGestureDetector::Property::PANNING;
39855   jresult = (int)result;
39856   return jresult;
39857 }
39858
39859
39860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39861   void * jresult ;
39862   Dali::PanGestureDetector::Property *result = 0 ;
39863
39864   {
39865     try {
39866       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39867     } catch (std::out_of_range& e) {
39868       {
39869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39870       };
39871     } catch (std::exception& e) {
39872       {
39873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39874       };
39875     } catch (Dali::DaliException e) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39878       };
39879     } catch (...) {
39880       {
39881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39882       };
39883     }
39884   }
39885
39886   jresult = (void *)result;
39887   return jresult;
39888 }
39889
39890
39891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39892   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39893
39894   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39895   {
39896     try {
39897       delete arg1;
39898     } catch (std::out_of_range& e) {
39899       {
39900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39901       };
39902     } catch (std::exception& e) {
39903       {
39904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39905       };
39906     } catch (Dali::DaliException e) {
39907       {
39908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39909       };
39910     } catch (...) {
39911       {
39912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39913       };
39914     }
39915   }
39916
39917 }
39918
39919
39920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39921   void * jresult ;
39922   Dali::Radian *result = 0 ;
39923
39924   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39925   jresult = (void *)result;
39926   return jresult;
39927 }
39928
39929
39930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39931   void * jresult ;
39932   Dali::Radian *result = 0 ;
39933
39934   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39935   jresult = (void *)result;
39936   return jresult;
39937 }
39938
39939
39940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39941   void * jresult ;
39942   Dali::Radian *result = 0 ;
39943
39944   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39945   jresult = (void *)result;
39946   return jresult;
39947 }
39948
39949
39950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39951   void * jresult ;
39952   Dali::Radian *result = 0 ;
39953
39954   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39955   jresult = (void *)result;
39956   return jresult;
39957 }
39958
39959
39960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39961   void * jresult ;
39962   Dali::Radian *result = 0 ;
39963
39964   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39965   jresult = (void *)result;
39966   return jresult;
39967 }
39968
39969
39970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39971   void * jresult ;
39972   Dali::Radian *result = 0 ;
39973
39974   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39975   jresult = (void *)result;
39976   return jresult;
39977 }
39978
39979
39980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39981   void * jresult ;
39982   Dali::Radian *result = 0 ;
39983
39984   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39985   jresult = (void *)result;
39986   return jresult;
39987 }
39988
39989
39990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39991   void * jresult ;
39992   Dali::PanGestureDetector *result = 0 ;
39993
39994   {
39995     try {
39996       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39997     } catch (std::out_of_range& e) {
39998       {
39999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (std::exception& e) {
40002       {
40003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40004       };
40005     } catch (Dali::DaliException e) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40008       };
40009     } catch (...) {
40010       {
40011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40012       };
40013     }
40014   }
40015
40016   jresult = (void *)result;
40017   return jresult;
40018 }
40019
40020
40021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40022   void * jresult ;
40023   Dali::PanGestureDetector result;
40024
40025   {
40026     try {
40027       result = Dali::PanGestureDetector::New();
40028     } catch (std::out_of_range& e) {
40029       {
40030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40031       };
40032     } catch (std::exception& e) {
40033       {
40034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40035       };
40036     } catch (Dali::DaliException e) {
40037       {
40038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40039       };
40040     } catch (...) {
40041       {
40042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40043       };
40044     }
40045   }
40046
40047   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40048   return jresult;
40049 }
40050
40051
40052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40053   void * jresult ;
40054   Dali::BaseHandle arg1 ;
40055   Dali::BaseHandle *argp1 ;
40056   Dali::PanGestureDetector result;
40057
40058   argp1 = (Dali::BaseHandle *)jarg1;
40059   if (!argp1) {
40060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40061     return 0;
40062   }
40063   arg1 = *argp1;
40064   {
40065     try {
40066       result = Dali::PanGestureDetector::DownCast(arg1);
40067     } catch (std::out_of_range& e) {
40068       {
40069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40070       };
40071     } catch (std::exception& e) {
40072       {
40073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40074       };
40075     } catch (Dali::DaliException e) {
40076       {
40077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40078       };
40079     } catch (...) {
40080       {
40081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40082       };
40083     }
40084   }
40085
40086   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40087   return jresult;
40088 }
40089
40090
40091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40092   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40093
40094   arg1 = (Dali::PanGestureDetector *)jarg1;
40095   {
40096     try {
40097       delete arg1;
40098     } catch (std::out_of_range& e) {
40099       {
40100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40101       };
40102     } catch (std::exception& e) {
40103       {
40104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40105       };
40106     } catch (Dali::DaliException e) {
40107       {
40108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40109       };
40110     } catch (...) {
40111       {
40112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40113       };
40114     }
40115   }
40116
40117 }
40118
40119
40120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40121   void * jresult ;
40122   Dali::PanGestureDetector *arg1 = 0 ;
40123   Dali::PanGestureDetector *result = 0 ;
40124
40125   arg1 = (Dali::PanGestureDetector *)jarg1;
40126   if (!arg1) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40128     return 0;
40129   }
40130   {
40131     try {
40132       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40133     } catch (std::out_of_range& e) {
40134       {
40135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40136       };
40137     } catch (std::exception& e) {
40138       {
40139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40140       };
40141     } catch (Dali::DaliException e) {
40142       {
40143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40144       };
40145     } catch (...) {
40146       {
40147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40148       };
40149     }
40150   }
40151
40152   jresult = (void *)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40158   void * jresult ;
40159   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40160   Dali::PanGestureDetector *arg2 = 0 ;
40161   Dali::PanGestureDetector *result = 0 ;
40162
40163   arg1 = (Dali::PanGestureDetector *)jarg1;
40164   arg2 = (Dali::PanGestureDetector *)jarg2;
40165   if (!arg2) {
40166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40167     return 0;
40168   }
40169   {
40170     try {
40171       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40172     } catch (std::out_of_range& e) {
40173       {
40174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40175       };
40176     } catch (std::exception& e) {
40177       {
40178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40179       };
40180     } catch (Dali::DaliException e) {
40181       {
40182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40183       };
40184     } catch (...) {
40185       {
40186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40187       };
40188     }
40189   }
40190
40191   jresult = (void *)result;
40192   return jresult;
40193 }
40194
40195
40196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40197   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40198   unsigned int arg2 ;
40199
40200   arg1 = (Dali::PanGestureDetector *)jarg1;
40201   arg2 = (unsigned int)jarg2;
40202   {
40203     try {
40204       (arg1)->SetMinimumTouchesRequired(arg2);
40205     } catch (std::out_of_range& e) {
40206       {
40207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40208       };
40209     } catch (std::exception& e) {
40210       {
40211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40212       };
40213     } catch (Dali::DaliException e) {
40214       {
40215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40216       };
40217     } catch (...) {
40218       {
40219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40220       };
40221     }
40222   }
40223
40224 }
40225
40226
40227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40228   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40229   unsigned int arg2 ;
40230
40231   arg1 = (Dali::PanGestureDetector *)jarg1;
40232   arg2 = (unsigned int)jarg2;
40233   {
40234     try {
40235       (arg1)->SetMaximumTouchesRequired(arg2);
40236     } catch (std::out_of_range& e) {
40237       {
40238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40239       };
40240     } catch (std::exception& e) {
40241       {
40242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40243       };
40244     } catch (Dali::DaliException e) {
40245       {
40246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40247       };
40248     } catch (...) {
40249       {
40250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40251       };
40252     }
40253   }
40254
40255 }
40256
40257
40258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40259   unsigned int jresult ;
40260   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40261   unsigned int result;
40262
40263   arg1 = (Dali::PanGestureDetector *)jarg1;
40264   {
40265     try {
40266       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40267     } catch (std::out_of_range& e) {
40268       {
40269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40270       };
40271     } catch (std::exception& e) {
40272       {
40273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40274       };
40275     } catch (Dali::DaliException e) {
40276       {
40277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40278       };
40279     } catch (...) {
40280       {
40281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40282       };
40283     }
40284   }
40285
40286   jresult = result;
40287   return jresult;
40288 }
40289
40290
40291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40292   unsigned int jresult ;
40293   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40294   unsigned int result;
40295
40296   arg1 = (Dali::PanGestureDetector *)jarg1;
40297   {
40298     try {
40299       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40300     } catch (std::out_of_range& e) {
40301       {
40302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40303       };
40304     } catch (std::exception& e) {
40305       {
40306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40307       };
40308     } catch (Dali::DaliException e) {
40309       {
40310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40311       };
40312     } catch (...) {
40313       {
40314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40315       };
40316     }
40317   }
40318
40319   jresult = result;
40320   return jresult;
40321 }
40322
40323
40324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40325   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40326   Dali::Radian arg2 ;
40327   Dali::Radian arg3 ;
40328   Dali::Radian *argp2 ;
40329   Dali::Radian *argp3 ;
40330
40331   arg1 = (Dali::PanGestureDetector *)jarg1;
40332   argp2 = (Dali::Radian *)jarg2;
40333   if (!argp2) {
40334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40335     return ;
40336   }
40337   arg2 = *argp2;
40338   argp3 = (Dali::Radian *)jarg3;
40339   if (!argp3) {
40340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40341     return ;
40342   }
40343   arg3 = *argp3;
40344   {
40345     try {
40346       (arg1)->AddAngle(arg2,arg3);
40347     } catch (std::out_of_range& e) {
40348       {
40349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40350       };
40351     } catch (std::exception& e) {
40352       {
40353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40354       };
40355     } catch (Dali::DaliException e) {
40356       {
40357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40358       };
40359     } catch (...) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40362       };
40363     }
40364   }
40365
40366 }
40367
40368
40369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40370   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40371   Dali::Radian arg2 ;
40372   Dali::Radian *argp2 ;
40373
40374   arg1 = (Dali::PanGestureDetector *)jarg1;
40375   argp2 = (Dali::Radian *)jarg2;
40376   if (!argp2) {
40377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40378     return ;
40379   }
40380   arg2 = *argp2;
40381   {
40382     try {
40383       (arg1)->AddAngle(arg2);
40384     } catch (std::out_of_range& e) {
40385       {
40386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40387       };
40388     } catch (std::exception& e) {
40389       {
40390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40391       };
40392     } catch (Dali::DaliException e) {
40393       {
40394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40395       };
40396     } catch (...) {
40397       {
40398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40399       };
40400     }
40401   }
40402
40403 }
40404
40405
40406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40407   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40408   Dali::Radian arg2 ;
40409   Dali::Radian arg3 ;
40410   Dali::Radian *argp2 ;
40411   Dali::Radian *argp3 ;
40412
40413   arg1 = (Dali::PanGestureDetector *)jarg1;
40414   argp2 = (Dali::Radian *)jarg2;
40415   if (!argp2) {
40416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40417     return ;
40418   }
40419   arg2 = *argp2;
40420   argp3 = (Dali::Radian *)jarg3;
40421   if (!argp3) {
40422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40423     return ;
40424   }
40425   arg3 = *argp3;
40426   {
40427     try {
40428       (arg1)->AddDirection(arg2,arg3);
40429     } catch (std::out_of_range& e) {
40430       {
40431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40432       };
40433     } catch (std::exception& e) {
40434       {
40435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40436       };
40437     } catch (Dali::DaliException e) {
40438       {
40439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40440       };
40441     } catch (...) {
40442       {
40443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40444       };
40445     }
40446   }
40447
40448 }
40449
40450
40451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40453   Dali::Radian arg2 ;
40454   Dali::Radian *argp2 ;
40455
40456   arg1 = (Dali::PanGestureDetector *)jarg1;
40457   argp2 = (Dali::Radian *)jarg2;
40458   if (!argp2) {
40459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40460     return ;
40461   }
40462   arg2 = *argp2;
40463   {
40464     try {
40465       (arg1)->AddDirection(arg2);
40466     } catch (std::out_of_range& e) {
40467       {
40468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40469       };
40470     } catch (std::exception& e) {
40471       {
40472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40473       };
40474     } catch (Dali::DaliException e) {
40475       {
40476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40477       };
40478     } catch (...) {
40479       {
40480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40481       };
40482     }
40483   }
40484
40485 }
40486
40487
40488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40489   unsigned long jresult ;
40490   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40491   size_t result;
40492
40493   arg1 = (Dali::PanGestureDetector *)jarg1;
40494   {
40495     try {
40496       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40497     } catch (std::out_of_range& e) {
40498       {
40499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40500       };
40501     } catch (std::exception& e) {
40502       {
40503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40504       };
40505     } catch (Dali::DaliException e) {
40506       {
40507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40508       };
40509     } catch (...) {
40510       {
40511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40512       };
40513     }
40514   }
40515
40516   jresult = (unsigned long)result;
40517   return jresult;
40518 }
40519
40520
40521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40522   void * jresult ;
40523   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40524   size_t arg2 ;
40525   Dali::PanGestureDetector::AngleThresholdPair result;
40526
40527   arg1 = (Dali::PanGestureDetector *)jarg1;
40528   arg2 = (size_t)jarg2;
40529   {
40530     try {
40531       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (Dali::DaliException e) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550
40551   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40557   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40558
40559   arg1 = (Dali::PanGestureDetector *)jarg1;
40560   {
40561     try {
40562       (arg1)->ClearAngles();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40578       };
40579     }
40580   }
40581
40582 }
40583
40584
40585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40586   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40587   Dali::Radian arg2 ;
40588   Dali::Radian *argp2 ;
40589
40590   arg1 = (Dali::PanGestureDetector *)jarg1;
40591   argp2 = (Dali::Radian *)jarg2;
40592   if (!argp2) {
40593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40594     return ;
40595   }
40596   arg2 = *argp2;
40597   {
40598     try {
40599       (arg1)->RemoveAngle(arg2);
40600     } catch (std::out_of_range& e) {
40601       {
40602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40603       };
40604     } catch (std::exception& e) {
40605       {
40606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40607       };
40608     } catch (Dali::DaliException e) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40611       };
40612     } catch (...) {
40613       {
40614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40615       };
40616     }
40617   }
40618
40619 }
40620
40621
40622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40623   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40624   Dali::Radian arg2 ;
40625   Dali::Radian *argp2 ;
40626
40627   arg1 = (Dali::PanGestureDetector *)jarg1;
40628   argp2 = (Dali::Radian *)jarg2;
40629   if (!argp2) {
40630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40631     return ;
40632   }
40633   arg2 = *argp2;
40634   {
40635     try {
40636       (arg1)->RemoveDirection(arg2);
40637     } catch (std::out_of_range& e) {
40638       {
40639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40640       };
40641     } catch (std::exception& e) {
40642       {
40643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40644       };
40645     } catch (Dali::DaliException e) {
40646       {
40647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40648       };
40649     } catch (...) {
40650       {
40651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40652       };
40653     }
40654   }
40655
40656 }
40657
40658
40659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40660   void * jresult ;
40661   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40662   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40663
40664   arg1 = (Dali::PanGestureDetector *)jarg1;
40665   {
40666     try {
40667       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40668     } catch (std::out_of_range& e) {
40669       {
40670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40671       };
40672     } catch (std::exception& e) {
40673       {
40674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (Dali::DaliException e) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40679       };
40680     } catch (...) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40683       };
40684     }
40685   }
40686
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40693   Dali::PanGesture *arg1 = 0 ;
40694
40695   arg1 = (Dali::PanGesture *)jarg1;
40696   if (!arg1) {
40697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40698     return ;
40699   }
40700   {
40701     try {
40702       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40703     } catch (std::out_of_range& e) {
40704       {
40705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40706       };
40707     } catch (std::exception& e) {
40708       {
40709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40710       };
40711     } catch (Dali::DaliException e) {
40712       {
40713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40714       };
40715     } catch (...) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40718       };
40719     }
40720   }
40721
40722 }
40723
40724
40725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40726   void * jresult ;
40727   Dali::PanGesture *result = 0 ;
40728
40729   {
40730     try {
40731       result = (Dali::PanGesture *)new Dali::PanGesture();
40732     } catch (std::out_of_range& e) {
40733       {
40734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40735       };
40736     } catch (std::exception& e) {
40737       {
40738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40739       };
40740     } catch (Dali::DaliException e) {
40741       {
40742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40743       };
40744     } catch (...) {
40745       {
40746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40747       };
40748     }
40749   }
40750
40751   jresult = (void *)result;
40752   return jresult;
40753 }
40754
40755
40756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40757   void * jresult ;
40758   Dali::Gesture::State arg1 ;
40759   Dali::PanGesture *result = 0 ;
40760
40761   arg1 = (Dali::Gesture::State)jarg1;
40762   {
40763     try {
40764       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40765     } catch (std::out_of_range& e) {
40766       {
40767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40768       };
40769     } catch (std::exception& e) {
40770       {
40771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (Dali::DaliException e) {
40774       {
40775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40780       };
40781     }
40782   }
40783
40784   jresult = (void *)result;
40785   return jresult;
40786 }
40787
40788
40789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40790   void * jresult ;
40791   Dali::PanGesture *arg1 = 0 ;
40792   Dali::PanGesture *result = 0 ;
40793
40794   arg1 = (Dali::PanGesture *)jarg1;
40795   if (!arg1) {
40796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40797     return 0;
40798   }
40799   {
40800     try {
40801       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40802     } catch (std::out_of_range& e) {
40803       {
40804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40805       };
40806     } catch (std::exception& e) {
40807       {
40808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (Dali::DaliException e) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40813       };
40814     } catch (...) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40817       };
40818     }
40819   }
40820
40821   jresult = (void *)result;
40822   return jresult;
40823 }
40824
40825
40826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40827   void * jresult ;
40828   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40829   Dali::PanGesture *arg2 = 0 ;
40830   Dali::PanGesture *result = 0 ;
40831
40832   arg1 = (Dali::PanGesture *)jarg1;
40833   arg2 = (Dali::PanGesture *)jarg2;
40834   if (!arg2) {
40835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40836     return 0;
40837   }
40838   {
40839     try {
40840       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40841     } catch (std::out_of_range& e) {
40842       {
40843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40844       };
40845     } catch (std::exception& e) {
40846       {
40847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40848       };
40849     } catch (Dali::DaliException e) {
40850       {
40851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40852       };
40853     } catch (...) {
40854       {
40855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40856       };
40857     }
40858   }
40859
40860   jresult = (void *)result;
40861   return jresult;
40862 }
40863
40864
40865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40866   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40867
40868   arg1 = (Dali::PanGesture *)jarg1;
40869   {
40870     try {
40871       delete arg1;
40872     } catch (std::out_of_range& e) {
40873       {
40874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40875       };
40876     } catch (std::exception& e) {
40877       {
40878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40879       };
40880     } catch (Dali::DaliException e) {
40881       {
40882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40883       };
40884     } catch (...) {
40885       {
40886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40887       };
40888     }
40889   }
40890
40891 }
40892
40893
40894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40895   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40896   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40897
40898   arg1 = (Dali::PanGesture *)jarg1;
40899   arg2 = (Dali::Vector2 *)jarg2;
40900   if (arg1) (arg1)->velocity = *arg2;
40901 }
40902
40903
40904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40905   void * jresult ;
40906   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40907   Dali::Vector2 *result = 0 ;
40908
40909   arg1 = (Dali::PanGesture *)jarg1;
40910   result = (Dali::Vector2 *)& ((arg1)->velocity);
40911   jresult = (void *)result;
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40917   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40918   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40919
40920   arg1 = (Dali::PanGesture *)jarg1;
40921   arg2 = (Dali::Vector2 *)jarg2;
40922   if (arg1) (arg1)->displacement = *arg2;
40923 }
40924
40925
40926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40927   void * jresult ;
40928   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40929   Dali::Vector2 *result = 0 ;
40930
40931   arg1 = (Dali::PanGesture *)jarg1;
40932   result = (Dali::Vector2 *)& ((arg1)->displacement);
40933   jresult = (void *)result;
40934   return jresult;
40935 }
40936
40937
40938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40939   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40940   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40941
40942   arg1 = (Dali::PanGesture *)jarg1;
40943   arg2 = (Dali::Vector2 *)jarg2;
40944   if (arg1) (arg1)->position = *arg2;
40945 }
40946
40947
40948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40949   void * jresult ;
40950   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40951   Dali::Vector2 *result = 0 ;
40952
40953   arg1 = (Dali::PanGesture *)jarg1;
40954   result = (Dali::Vector2 *)& ((arg1)->position);
40955   jresult = (void *)result;
40956   return jresult;
40957 }
40958
40959
40960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40961   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40962   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40963
40964   arg1 = (Dali::PanGesture *)jarg1;
40965   arg2 = (Dali::Vector2 *)jarg2;
40966   if (arg1) (arg1)->screenVelocity = *arg2;
40967 }
40968
40969
40970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40971   void * jresult ;
40972   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40973   Dali::Vector2 *result = 0 ;
40974
40975   arg1 = (Dali::PanGesture *)jarg1;
40976   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40977   jresult = (void *)result;
40978   return jresult;
40979 }
40980
40981
40982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40983   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40984   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40985
40986   arg1 = (Dali::PanGesture *)jarg1;
40987   arg2 = (Dali::Vector2 *)jarg2;
40988   if (arg1) (arg1)->screenDisplacement = *arg2;
40989 }
40990
40991
40992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40993   void * jresult ;
40994   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40995   Dali::Vector2 *result = 0 ;
40996
40997   arg1 = (Dali::PanGesture *)jarg1;
40998   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40999   jresult = (void *)result;
41000   return jresult;
41001 }
41002
41003
41004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41005   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41006   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41007
41008   arg1 = (Dali::PanGesture *)jarg1;
41009   arg2 = (Dali::Vector2 *)jarg2;
41010   if (arg1) (arg1)->screenPosition = *arg2;
41011 }
41012
41013
41014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41015   void * jresult ;
41016   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41017   Dali::Vector2 *result = 0 ;
41018
41019   arg1 = (Dali::PanGesture *)jarg1;
41020   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41021   jresult = (void *)result;
41022   return jresult;
41023 }
41024
41025
41026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41027   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41028   unsigned int arg2 ;
41029
41030   arg1 = (Dali::PanGesture *)jarg1;
41031   arg2 = (unsigned int)jarg2;
41032   if (arg1) (arg1)->numberOfTouches = arg2;
41033 }
41034
41035
41036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41037   unsigned int jresult ;
41038   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41039   unsigned int result;
41040
41041   arg1 = (Dali::PanGesture *)jarg1;
41042   result = (unsigned int) ((arg1)->numberOfTouches);
41043   jresult = result;
41044   return jresult;
41045 }
41046
41047
41048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41049   float jresult ;
41050   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41051   float result;
41052
41053   arg1 = (Dali::PanGesture *)jarg1;
41054   {
41055     try {
41056       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41057     } catch (std::out_of_range& e) {
41058       {
41059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41060       };
41061     } catch (std::exception& e) {
41062       {
41063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41064       };
41065     } catch (Dali::DaliException e) {
41066       {
41067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41068       };
41069     } catch (...) {
41070       {
41071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41072       };
41073     }
41074   }
41075
41076   jresult = result;
41077   return jresult;
41078 }
41079
41080
41081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41082   float jresult ;
41083   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41084   float result;
41085
41086   arg1 = (Dali::PanGesture *)jarg1;
41087   {
41088     try {
41089       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41090     } catch (std::out_of_range& e) {
41091       {
41092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41093       };
41094     } catch (std::exception& e) {
41095       {
41096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41097       };
41098     } catch (Dali::DaliException e) {
41099       {
41100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41101       };
41102     } catch (...) {
41103       {
41104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41105       };
41106     }
41107   }
41108
41109   jresult = result;
41110   return jresult;
41111 }
41112
41113
41114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41115   float jresult ;
41116   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41117   float result;
41118
41119   arg1 = (Dali::PanGesture *)jarg1;
41120   {
41121     try {
41122       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41123     } catch (std::out_of_range& e) {
41124       {
41125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41126       };
41127     } catch (std::exception& e) {
41128       {
41129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41130       };
41131     } catch (Dali::DaliException e) {
41132       {
41133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41134       };
41135     } catch (...) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41138       };
41139     }
41140   }
41141
41142   jresult = result;
41143   return jresult;
41144 }
41145
41146
41147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41148   float jresult ;
41149   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41150   float result;
41151
41152   arg1 = (Dali::PanGesture *)jarg1;
41153   {
41154     try {
41155       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41156     } catch (std::out_of_range& e) {
41157       {
41158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41159       };
41160     } catch (std::exception& e) {
41161       {
41162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41163       };
41164     } catch (Dali::DaliException e) {
41165       {
41166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41167       };
41168     } catch (...) {
41169       {
41170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41171       };
41172     }
41173   }
41174
41175   jresult = result;
41176   return jresult;
41177 }
41178
41179
41180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41181   void * jresult ;
41182   Dali::PinchGestureDetector *result = 0 ;
41183
41184   {
41185     try {
41186       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41187     } catch (std::out_of_range& e) {
41188       {
41189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41190       };
41191     } catch (std::exception& e) {
41192       {
41193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41194       };
41195     } catch (Dali::DaliException e) {
41196       {
41197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41198       };
41199     } catch (...) {
41200       {
41201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41202       };
41203     }
41204   }
41205
41206   jresult = (void *)result;
41207   return jresult;
41208 }
41209
41210
41211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41212   void * jresult ;
41213   Dali::PinchGestureDetector result;
41214
41215   {
41216     try {
41217       result = Dali::PinchGestureDetector::New();
41218     } catch (std::out_of_range& e) {
41219       {
41220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41221       };
41222     } catch (std::exception& e) {
41223       {
41224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41225       };
41226     } catch (Dali::DaliException e) {
41227       {
41228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41229       };
41230     } catch (...) {
41231       {
41232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41233       };
41234     }
41235   }
41236
41237   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41238   return jresult;
41239 }
41240
41241
41242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41243   void * jresult ;
41244   Dali::BaseHandle arg1 ;
41245   Dali::BaseHandle *argp1 ;
41246   Dali::PinchGestureDetector result;
41247
41248   argp1 = (Dali::BaseHandle *)jarg1;
41249   if (!argp1) {
41250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41251     return 0;
41252   }
41253   arg1 = *argp1;
41254   {
41255     try {
41256       result = Dali::PinchGestureDetector::DownCast(arg1);
41257     } catch (std::out_of_range& e) {
41258       {
41259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41260       };
41261     } catch (std::exception& e) {
41262       {
41263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41264       };
41265     } catch (Dali::DaliException e) {
41266       {
41267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41268       };
41269     } catch (...) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41272       };
41273     }
41274   }
41275
41276   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41277   return jresult;
41278 }
41279
41280
41281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41282   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41283
41284   arg1 = (Dali::PinchGestureDetector *)jarg1;
41285   {
41286     try {
41287       delete arg1;
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41295       };
41296     } catch (Dali::DaliException e) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41299       };
41300     } catch (...) {
41301       {
41302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41303       };
41304     }
41305   }
41306
41307 }
41308
41309
41310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41311   void * jresult ;
41312   Dali::PinchGestureDetector *arg1 = 0 ;
41313   Dali::PinchGestureDetector *result = 0 ;
41314
41315   arg1 = (Dali::PinchGestureDetector *)jarg1;
41316   if (!arg1) {
41317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41318     return 0;
41319   }
41320   {
41321     try {
41322       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41323     } catch (std::out_of_range& e) {
41324       {
41325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41326       };
41327     } catch (std::exception& e) {
41328       {
41329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41330       };
41331     } catch (Dali::DaliException e) {
41332       {
41333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41334       };
41335     } catch (...) {
41336       {
41337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41338       };
41339     }
41340   }
41341
41342   jresult = (void *)result;
41343   return jresult;
41344 }
41345
41346
41347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41348   void * jresult ;
41349   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41350   Dali::PinchGestureDetector *arg2 = 0 ;
41351   Dali::PinchGestureDetector *result = 0 ;
41352
41353   arg1 = (Dali::PinchGestureDetector *)jarg1;
41354   arg2 = (Dali::PinchGestureDetector *)jarg2;
41355   if (!arg2) {
41356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41357     return 0;
41358   }
41359   {
41360     try {
41361       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41362     } catch (std::out_of_range& e) {
41363       {
41364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41365       };
41366     } catch (std::exception& e) {
41367       {
41368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41369       };
41370     } catch (Dali::DaliException e) {
41371       {
41372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41373       };
41374     } catch (...) {
41375       {
41376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41377       };
41378     }
41379   }
41380
41381   jresult = (void *)result;
41382   return jresult;
41383 }
41384
41385
41386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41387   void * jresult ;
41388   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41389   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41390
41391   arg1 = (Dali::PinchGestureDetector *)jarg1;
41392   {
41393     try {
41394       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41395     } catch (std::out_of_range& e) {
41396       {
41397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41398       };
41399     } catch (std::exception& e) {
41400       {
41401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41402       };
41403     } catch (Dali::DaliException e) {
41404       {
41405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41406       };
41407     } catch (...) {
41408       {
41409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41410       };
41411     }
41412   }
41413
41414   jresult = (void *)result;
41415   return jresult;
41416 }
41417
41418
41419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41420   void * jresult ;
41421   Dali::Gesture::State arg1 ;
41422   Dali::PinchGesture *result = 0 ;
41423
41424   arg1 = (Dali::Gesture::State)jarg1;
41425   {
41426     try {
41427       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41428     } catch (std::out_of_range& e) {
41429       {
41430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41431       };
41432     } catch (std::exception& e) {
41433       {
41434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41435       };
41436     } catch (Dali::DaliException e) {
41437       {
41438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41439       };
41440     } catch (...) {
41441       {
41442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41443       };
41444     }
41445   }
41446
41447   jresult = (void *)result;
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41453   void * jresult ;
41454   Dali::PinchGesture *arg1 = 0 ;
41455   Dali::PinchGesture *result = 0 ;
41456
41457   arg1 = (Dali::PinchGesture *)jarg1;
41458   if (!arg1) {
41459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41460     return 0;
41461   }
41462   {
41463     try {
41464       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*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_PinchGesture_Assign(void * jarg1, void * jarg2) {
41490   void * jresult ;
41491   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41492   Dali::PinchGesture *arg2 = 0 ;
41493   Dali::PinchGesture *result = 0 ;
41494
41495   arg1 = (Dali::PinchGesture *)jarg1;
41496   arg2 = (Dali::PinchGesture *)jarg2;
41497   if (!arg2) {
41498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41499     return 0;
41500   }
41501   {
41502     try {
41503       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41504     } catch (std::out_of_range& e) {
41505       {
41506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41507       };
41508     } catch (std::exception& e) {
41509       {
41510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41511       };
41512     } catch (Dali::DaliException e) {
41513       {
41514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41515       };
41516     } catch (...) {
41517       {
41518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41519       };
41520     }
41521   }
41522
41523   jresult = (void *)result;
41524   return jresult;
41525 }
41526
41527
41528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41529   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41530
41531   arg1 = (Dali::PinchGesture *)jarg1;
41532   {
41533     try {
41534       delete arg1;
41535     } catch (std::out_of_range& e) {
41536       {
41537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41538       };
41539     } catch (std::exception& e) {
41540       {
41541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41542       };
41543     } catch (Dali::DaliException e) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41546       };
41547     } catch (...) {
41548       {
41549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41550       };
41551     }
41552   }
41553
41554 }
41555
41556
41557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41558   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41559   float arg2 ;
41560
41561   arg1 = (Dali::PinchGesture *)jarg1;
41562   arg2 = (float)jarg2;
41563   if (arg1) (arg1)->scale = arg2;
41564 }
41565
41566
41567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41568   float jresult ;
41569   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41570   float result;
41571
41572   arg1 = (Dali::PinchGesture *)jarg1;
41573   result = (float) ((arg1)->scale);
41574   jresult = result;
41575   return jresult;
41576 }
41577
41578
41579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41580   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41581   float arg2 ;
41582
41583   arg1 = (Dali::PinchGesture *)jarg1;
41584   arg2 = (float)jarg2;
41585   if (arg1) (arg1)->speed = arg2;
41586 }
41587
41588
41589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41590   float jresult ;
41591   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41592   float result;
41593
41594   arg1 = (Dali::PinchGesture *)jarg1;
41595   result = (float) ((arg1)->speed);
41596   jresult = result;
41597   return jresult;
41598 }
41599
41600
41601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41602   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41603   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41604
41605   arg1 = (Dali::PinchGesture *)jarg1;
41606   arg2 = (Dali::Vector2 *)jarg2;
41607   if (arg1) (arg1)->screenCenterPoint = *arg2;
41608 }
41609
41610
41611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41612   void * jresult ;
41613   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41614   Dali::Vector2 *result = 0 ;
41615
41616   arg1 = (Dali::PinchGesture *)jarg1;
41617   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41618   jresult = (void *)result;
41619   return jresult;
41620 }
41621
41622
41623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41624   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41625   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41626
41627   arg1 = (Dali::PinchGesture *)jarg1;
41628   arg2 = (Dali::Vector2 *)jarg2;
41629   if (arg1) (arg1)->localCenterPoint = *arg2;
41630 }
41631
41632
41633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41634   void * jresult ;
41635   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41636   Dali::Vector2 *result = 0 ;
41637
41638   arg1 = (Dali::PinchGesture *)jarg1;
41639   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41640   jresult = (void *)result;
41641   return jresult;
41642 }
41643
41644
41645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41646   void * jresult ;
41647   Dali::TapGestureDetector *result = 0 ;
41648
41649   {
41650     try {
41651       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41652     } catch (std::out_of_range& e) {
41653       {
41654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41655       };
41656     } catch (std::exception& e) {
41657       {
41658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41659       };
41660     } catch (Dali::DaliException e) {
41661       {
41662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41663       };
41664     } catch (...) {
41665       {
41666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41667       };
41668     }
41669   }
41670
41671   jresult = (void *)result;
41672   return jresult;
41673 }
41674
41675
41676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41677   void * jresult ;
41678   Dali::TapGestureDetector result;
41679
41680   {
41681     try {
41682       result = Dali::TapGestureDetector::New();
41683     } catch (std::out_of_range& e) {
41684       {
41685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41686       };
41687     } catch (std::exception& e) {
41688       {
41689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41690       };
41691     } catch (Dali::DaliException e) {
41692       {
41693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41694       };
41695     } catch (...) {
41696       {
41697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41698       };
41699     }
41700   }
41701
41702   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41703   return jresult;
41704 }
41705
41706
41707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41708   void * jresult ;
41709   unsigned int arg1 ;
41710   Dali::TapGestureDetector result;
41711
41712   arg1 = (unsigned int)jarg1;
41713   {
41714     try {
41715       result = Dali::TapGestureDetector::New(arg1);
41716     } catch (std::out_of_range& e) {
41717       {
41718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41719       };
41720     } catch (std::exception& e) {
41721       {
41722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41723       };
41724     } catch (Dali::DaliException e) {
41725       {
41726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41727       };
41728     } catch (...) {
41729       {
41730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41731       };
41732     }
41733   }
41734
41735   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41736   return jresult;
41737 }
41738
41739
41740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41741   void * jresult ;
41742   Dali::BaseHandle arg1 ;
41743   Dali::BaseHandle *argp1 ;
41744   Dali::TapGestureDetector result;
41745
41746   argp1 = (Dali::BaseHandle *)jarg1;
41747   if (!argp1) {
41748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41749     return 0;
41750   }
41751   arg1 = *argp1;
41752   {
41753     try {
41754       result = Dali::TapGestureDetector::DownCast(arg1);
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (Dali::DaliException e) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41766       };
41767     } catch (...) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41770       };
41771     }
41772   }
41773
41774   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41780   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41781
41782   arg1 = (Dali::TapGestureDetector *)jarg1;
41783   {
41784     try {
41785       delete arg1;
41786     } catch (std::out_of_range& e) {
41787       {
41788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41789       };
41790     } catch (std::exception& e) {
41791       {
41792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41793       };
41794     } catch (Dali::DaliException e) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41801       };
41802     }
41803   }
41804
41805 }
41806
41807
41808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41809   void * jresult ;
41810   Dali::TapGestureDetector *arg1 = 0 ;
41811   Dali::TapGestureDetector *result = 0 ;
41812
41813   arg1 = (Dali::TapGestureDetector *)jarg1;
41814   if (!arg1) {
41815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41816     return 0;
41817   }
41818   {
41819     try {
41820       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41821     } catch (std::out_of_range& e) {
41822       {
41823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41824       };
41825     } catch (std::exception& e) {
41826       {
41827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41828       };
41829     } catch (Dali::DaliException e) {
41830       {
41831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41832       };
41833     } catch (...) {
41834       {
41835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41836       };
41837     }
41838   }
41839
41840   jresult = (void *)result;
41841   return jresult;
41842 }
41843
41844
41845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41846   void * jresult ;
41847   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41848   Dali::TapGestureDetector *arg2 = 0 ;
41849   Dali::TapGestureDetector *result = 0 ;
41850
41851   arg1 = (Dali::TapGestureDetector *)jarg1;
41852   arg2 = (Dali::TapGestureDetector *)jarg2;
41853   if (!arg2) {
41854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41855     return 0;
41856   }
41857   {
41858     try {
41859       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41860     } catch (std::out_of_range& e) {
41861       {
41862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41863       };
41864     } catch (std::exception& e) {
41865       {
41866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41867       };
41868     } catch (Dali::DaliException e) {
41869       {
41870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41871       };
41872     } catch (...) {
41873       {
41874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41875       };
41876     }
41877   }
41878
41879   jresult = (void *)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41885   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41886   unsigned int arg2 ;
41887
41888   arg1 = (Dali::TapGestureDetector *)jarg1;
41889   arg2 = (unsigned int)jarg2;
41890   {
41891     try {
41892       (arg1)->SetMinimumTapsRequired(arg2);
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41900       };
41901     } catch (Dali::DaliException e) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41904       };
41905     } catch (...) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41908       };
41909     }
41910   }
41911
41912 }
41913
41914
41915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41916   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41917   unsigned int arg2 ;
41918
41919   arg1 = (Dali::TapGestureDetector *)jarg1;
41920   arg2 = (unsigned int)jarg2;
41921   {
41922     try {
41923       (arg1)->SetMaximumTapsRequired(arg2);
41924     } catch (std::out_of_range& e) {
41925       {
41926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41927       };
41928     } catch (std::exception& e) {
41929       {
41930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41931       };
41932     } catch (Dali::DaliException e) {
41933       {
41934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41935       };
41936     } catch (...) {
41937       {
41938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41939       };
41940     }
41941   }
41942
41943 }
41944
41945
41946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41947   unsigned int jresult ;
41948   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41949   unsigned int result;
41950
41951   arg1 = (Dali::TapGestureDetector *)jarg1;
41952   {
41953     try {
41954       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41955     } catch (std::out_of_range& e) {
41956       {
41957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41958       };
41959     } catch (std::exception& e) {
41960       {
41961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (Dali::DaliException e) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41966       };
41967     } catch (...) {
41968       {
41969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41970       };
41971     }
41972   }
41973
41974   jresult = result;
41975   return jresult;
41976 }
41977
41978
41979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41980   unsigned int jresult ;
41981   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41982   unsigned int result;
41983
41984   arg1 = (Dali::TapGestureDetector *)jarg1;
41985   {
41986     try {
41987       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41988     } catch (std::out_of_range& e) {
41989       {
41990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41991       };
41992     } catch (std::exception& e) {
41993       {
41994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41995       };
41996     } catch (Dali::DaliException e) {
41997       {
41998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41999       };
42000     } catch (...) {
42001       {
42002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42003       };
42004     }
42005   }
42006
42007   jresult = result;
42008   return jresult;
42009 }
42010
42011
42012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42013   void * jresult ;
42014   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42015   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42016
42017   arg1 = (Dali::TapGestureDetector *)jarg1;
42018   {
42019     try {
42020       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42021     } catch (std::out_of_range& e) {
42022       {
42023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42024       };
42025     } catch (std::exception& e) {
42026       {
42027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42028       };
42029     } catch (Dali::DaliException e) {
42030       {
42031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42032       };
42033     } catch (...) {
42034       {
42035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42036       };
42037     }
42038   }
42039
42040   jresult = (void *)result;
42041   return jresult;
42042 }
42043
42044
42045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42046   void * jresult ;
42047   Dali::TapGesture *result = 0 ;
42048
42049   {
42050     try {
42051       result = (Dali::TapGesture *)new Dali::TapGesture();
42052     } catch (std::out_of_range& e) {
42053       {
42054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42055       };
42056     } catch (std::exception& e) {
42057       {
42058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42059       };
42060     } catch (Dali::DaliException e) {
42061       {
42062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42063       };
42064     } catch (...) {
42065       {
42066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42067       };
42068     }
42069   }
42070
42071   jresult = (void *)result;
42072   return jresult;
42073 }
42074
42075
42076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42077   void * jresult ;
42078   Dali::TapGesture *arg1 = 0 ;
42079   Dali::TapGesture *result = 0 ;
42080
42081   arg1 = (Dali::TapGesture *)jarg1;
42082   if (!arg1) {
42083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42084     return 0;
42085   }
42086   {
42087     try {
42088       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42089     } catch (std::out_of_range& e) {
42090       {
42091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (std::exception& e) {
42094       {
42095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42096       };
42097     } catch (Dali::DaliException e) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42100       };
42101     } catch (...) {
42102       {
42103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42104       };
42105     }
42106   }
42107
42108   jresult = (void *)result;
42109   return jresult;
42110 }
42111
42112
42113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42114   void * jresult ;
42115   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42116   Dali::TapGesture *arg2 = 0 ;
42117   Dali::TapGesture *result = 0 ;
42118
42119   arg1 = (Dali::TapGesture *)jarg1;
42120   arg2 = (Dali::TapGesture *)jarg2;
42121   if (!arg2) {
42122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42123     return 0;
42124   }
42125   {
42126     try {
42127       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
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_delete_TapGesture(void * jarg1) {
42153   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42154
42155   arg1 = (Dali::TapGesture *)jarg1;
42156   {
42157     try {
42158       delete arg1;
42159     } catch (std::out_of_range& e) {
42160       {
42161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42162       };
42163     } catch (std::exception& e) {
42164       {
42165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42166       };
42167     } catch (Dali::DaliException e) {
42168       {
42169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42170       };
42171     } catch (...) {
42172       {
42173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42174       };
42175     }
42176   }
42177
42178 }
42179
42180
42181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42182   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42183   unsigned int arg2 ;
42184
42185   arg1 = (Dali::TapGesture *)jarg1;
42186   arg2 = (unsigned int)jarg2;
42187   if (arg1) (arg1)->numberOfTaps = arg2;
42188 }
42189
42190
42191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42192   unsigned int jresult ;
42193   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42194   unsigned int result;
42195
42196   arg1 = (Dali::TapGesture *)jarg1;
42197   result = (unsigned int) ((arg1)->numberOfTaps);
42198   jresult = result;
42199   return jresult;
42200 }
42201
42202
42203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42204   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42205   unsigned int arg2 ;
42206
42207   arg1 = (Dali::TapGesture *)jarg1;
42208   arg2 = (unsigned int)jarg2;
42209   if (arg1) (arg1)->numberOfTouches = arg2;
42210 }
42211
42212
42213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42214   unsigned int jresult ;
42215   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42216   unsigned int result;
42217
42218   arg1 = (Dali::TapGesture *)jarg1;
42219   result = (unsigned int) ((arg1)->numberOfTouches);
42220   jresult = result;
42221   return jresult;
42222 }
42223
42224
42225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42226   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42227   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42228
42229   arg1 = (Dali::TapGesture *)jarg1;
42230   arg2 = (Dali::Vector2 *)jarg2;
42231   if (arg1) (arg1)->screenPoint = *arg2;
42232 }
42233
42234
42235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42236   void * jresult ;
42237   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42238   Dali::Vector2 *result = 0 ;
42239
42240   arg1 = (Dali::TapGesture *)jarg1;
42241   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42242   jresult = (void *)result;
42243   return jresult;
42244 }
42245
42246
42247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42248   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42249   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42250
42251   arg1 = (Dali::TapGesture *)jarg1;
42252   arg2 = (Dali::Vector2 *)jarg2;
42253   if (arg1) (arg1)->localPoint = *arg2;
42254 }
42255
42256
42257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42258   void * jresult ;
42259   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42260   Dali::Vector2 *result = 0 ;
42261
42262   arg1 = (Dali::TapGesture *)jarg1;
42263   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42264   jresult = (void *)result;
42265   return jresult;
42266 }
42267
42268
42269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42270   void * jresult ;
42271   Dali::AlphaFunction *result = 0 ;
42272
42273   {
42274     try {
42275       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42276     } catch (std::out_of_range& e) {
42277       {
42278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42279       };
42280     } catch (std::exception& e) {
42281       {
42282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42283       };
42284     } catch (Dali::DaliException e) {
42285       {
42286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42287       };
42288     } catch (...) {
42289       {
42290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42291       };
42292     }
42293   }
42294
42295   jresult = (void *)result;
42296   return jresult;
42297 }
42298
42299
42300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42301   void * jresult ;
42302   Dali::AlphaFunction::BuiltinFunction arg1 ;
42303   Dali::AlphaFunction *result = 0 ;
42304
42305   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42306   {
42307     try {
42308       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42309     } catch (std::out_of_range& e) {
42310       {
42311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42312       };
42313     } catch (std::exception& e) {
42314       {
42315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42316       };
42317     } catch (Dali::DaliException e) {
42318       {
42319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42320       };
42321     } catch (...) {
42322       {
42323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42324       };
42325     }
42326   }
42327
42328   jresult = (void *)result;
42329   return jresult;
42330 }
42331
42332
42333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42334   void * jresult ;
42335   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42336   Dali::AlphaFunction *result = 0 ;
42337
42338   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42339   {
42340     try {
42341       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42342     } catch (std::out_of_range& e) {
42343       {
42344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42345       };
42346     } catch (std::exception& e) {
42347       {
42348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42349       };
42350     } catch (Dali::DaliException e) {
42351       {
42352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42353       };
42354     } catch (...) {
42355       {
42356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42357       };
42358     }
42359   }
42360
42361   jresult = (void *)result;
42362   return jresult;
42363 }
42364
42365
42366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42367   void * jresult ;
42368   Dali::Vector2 *arg1 = 0 ;
42369   Dali::Vector2 *arg2 = 0 ;
42370   Dali::AlphaFunction *result = 0 ;
42371
42372   arg1 = (Dali::Vector2 *)jarg1;
42373   if (!arg1) {
42374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42375     return 0;
42376   }
42377   arg2 = (Dali::Vector2 *)jarg2;
42378   if (!arg2) {
42379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42380     return 0;
42381   }
42382   {
42383     try {
42384       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42385     } catch (std::out_of_range& e) {
42386       {
42387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42388       };
42389     } catch (std::exception& e) {
42390       {
42391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42392       };
42393     } catch (Dali::DaliException e) {
42394       {
42395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42396       };
42397     } catch (...) {
42398       {
42399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42400       };
42401     }
42402   }
42403
42404   jresult = (void *)result;
42405   return jresult;
42406 }
42407
42408
42409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42410   void * jresult ;
42411   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42412   Dali::Vector4 result;
42413
42414   arg1 = (Dali::AlphaFunction *)jarg1;
42415   {
42416     try {
42417       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42418     } catch (std::out_of_range& e) {
42419       {
42420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42421       };
42422     } catch (std::exception& e) {
42423       {
42424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42425       };
42426     } catch (Dali::DaliException e) {
42427       {
42428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42429       };
42430     } catch (...) {
42431       {
42432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42433       };
42434     }
42435   }
42436
42437   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42438   return jresult;
42439 }
42440
42441
42442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42443   void * jresult ;
42444   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42445   Dali::AlphaFunctionPrototype result;
42446
42447   arg1 = (Dali::AlphaFunction *)jarg1;
42448   {
42449     try {
42450       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42451     } catch (std::out_of_range& e) {
42452       {
42453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42454       };
42455     } catch (std::exception& e) {
42456       {
42457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42458       };
42459     } catch (Dali::DaliException e) {
42460       {
42461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42462       };
42463     } catch (...) {
42464       {
42465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42466       };
42467     }
42468   }
42469
42470   jresult = (void *)result;
42471   return jresult;
42472 }
42473
42474
42475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42476   int jresult ;
42477   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42478   Dali::AlphaFunction::BuiltinFunction result;
42479
42480   arg1 = (Dali::AlphaFunction *)jarg1;
42481   {
42482     try {
42483       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42484     } catch (std::out_of_range& e) {
42485       {
42486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42487       };
42488     } catch (std::exception& e) {
42489       {
42490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42491       };
42492     } catch (Dali::DaliException e) {
42493       {
42494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42495       };
42496     } catch (...) {
42497       {
42498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42499       };
42500     }
42501   }
42502
42503   jresult = (int)result;
42504   return jresult;
42505 }
42506
42507
42508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42509   int jresult ;
42510   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42511   Dali::AlphaFunction::Mode result;
42512
42513   arg1 = (Dali::AlphaFunction *)jarg1;
42514   {
42515     try {
42516       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42517     } catch (std::out_of_range& e) {
42518       {
42519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42520       };
42521     } catch (std::exception& e) {
42522       {
42523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42524       };
42525     } catch (Dali::DaliException e) {
42526       {
42527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42528       };
42529     } catch (...) {
42530       {
42531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42532       };
42533     }
42534   }
42535
42536   jresult = (int)result;
42537   return jresult;
42538 }
42539
42540
42541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42542   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42543
42544   arg1 = (Dali::AlphaFunction *)jarg1;
42545   {
42546     try {
42547       delete arg1;
42548     } catch (std::out_of_range& e) {
42549       {
42550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42551       };
42552     } catch (std::exception& e) {
42553       {
42554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42555       };
42556     } catch (Dali::DaliException e) {
42557       {
42558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42559       };
42560     } catch (...) {
42561       {
42562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42563       };
42564     }
42565   }
42566
42567 }
42568
42569
42570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42571   void * jresult ;
42572   Dali::KeyFrames result;
42573
42574   {
42575     try {
42576       result = Dali::KeyFrames::New();
42577     } catch (std::out_of_range& e) {
42578       {
42579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42580       };
42581     } catch (std::exception& e) {
42582       {
42583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42584       };
42585     } catch (Dali::DaliException e) {
42586       {
42587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42588       };
42589     } catch (...) {
42590       {
42591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42592       };
42593     }
42594   }
42595
42596   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42597   return jresult;
42598 }
42599
42600
42601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42602   void * jresult ;
42603   Dali::BaseHandle arg1 ;
42604   Dali::BaseHandle *argp1 ;
42605   Dali::KeyFrames result;
42606
42607   argp1 = (Dali::BaseHandle *)jarg1;
42608   if (!argp1) {
42609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42610     return 0;
42611   }
42612   arg1 = *argp1;
42613   {
42614     try {
42615       result = Dali::KeyFrames::DownCast(arg1);
42616     } catch (std::out_of_range& e) {
42617       {
42618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42619       };
42620     } catch (std::exception& e) {
42621       {
42622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42623       };
42624     } catch (Dali::DaliException e) {
42625       {
42626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42627       };
42628     } catch (...) {
42629       {
42630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42631       };
42632     }
42633   }
42634
42635   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42636   return jresult;
42637 }
42638
42639
42640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42641   void * jresult ;
42642   Dali::KeyFrames *result = 0 ;
42643
42644   {
42645     try {
42646       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42647     } catch (std::out_of_range& e) {
42648       {
42649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42650       };
42651     } catch (std::exception& e) {
42652       {
42653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42654       };
42655     } catch (Dali::DaliException e) {
42656       {
42657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42658       };
42659     } catch (...) {
42660       {
42661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42662       };
42663     }
42664   }
42665
42666   jresult = (void *)result;
42667   return jresult;
42668 }
42669
42670
42671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42672   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42673
42674   arg1 = (Dali::KeyFrames *)jarg1;
42675   {
42676     try {
42677       delete arg1;
42678     } catch (std::out_of_range& e) {
42679       {
42680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42681       };
42682     } catch (std::exception& e) {
42683       {
42684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42685       };
42686     } catch (Dali::DaliException e) {
42687       {
42688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42689       };
42690     } catch (...) {
42691       {
42692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42693       };
42694     }
42695   }
42696
42697 }
42698
42699
42700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42701   void * jresult ;
42702   Dali::KeyFrames *arg1 = 0 ;
42703   Dali::KeyFrames *result = 0 ;
42704
42705   arg1 = (Dali::KeyFrames *)jarg1;
42706   if (!arg1) {
42707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42708     return 0;
42709   }
42710   {
42711     try {
42712       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42713     } catch (std::out_of_range& e) {
42714       {
42715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42716       };
42717     } catch (std::exception& e) {
42718       {
42719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42720       };
42721     } catch (Dali::DaliException e) {
42722       {
42723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42724       };
42725     } catch (...) {
42726       {
42727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42728       };
42729     }
42730   }
42731
42732   jresult = (void *)result;
42733   return jresult;
42734 }
42735
42736
42737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42738   void * jresult ;
42739   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42740   Dali::KeyFrames *arg2 = 0 ;
42741   Dali::KeyFrames *result = 0 ;
42742
42743   arg1 = (Dali::KeyFrames *)jarg1;
42744   arg2 = (Dali::KeyFrames *)jarg2;
42745   if (!arg2) {
42746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42747     return 0;
42748   }
42749   {
42750     try {
42751       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
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 int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42777   int jresult ;
42778   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42779   Dali::Property::Type result;
42780
42781   arg1 = (Dali::KeyFrames *)jarg1;
42782   {
42783     try {
42784       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42785     } catch (std::out_of_range& e) {
42786       {
42787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42788       };
42789     } catch (std::exception& e) {
42790       {
42791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42792       };
42793     } catch (Dali::DaliException e) {
42794       {
42795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42796       };
42797     } catch (...) {
42798       {
42799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42800       };
42801     }
42802   }
42803
42804   jresult = (int)result;
42805   return jresult;
42806 }
42807
42808
42809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42810   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42811   float arg2 ;
42812   Dali::Property::Value arg3 ;
42813   Dali::Property::Value *argp3 ;
42814
42815   arg1 = (Dali::KeyFrames *)jarg1;
42816   arg2 = (float)jarg2;
42817   argp3 = (Dali::Property::Value *)jarg3;
42818   if (!argp3) {
42819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42820     return ;
42821   }
42822   arg3 = *argp3;
42823   {
42824     try {
42825       (arg1)->Add(arg2,arg3);
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42833       };
42834     } catch (Dali::DaliException e) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42837       };
42838     } catch (...) {
42839       {
42840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42841       };
42842     }
42843   }
42844
42845 }
42846
42847
42848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42849   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42850   float arg2 ;
42851   Dali::Property::Value arg3 ;
42852   Dali::AlphaFunction arg4 ;
42853   Dali::Property::Value *argp3 ;
42854   Dali::AlphaFunction *argp4 ;
42855
42856   arg1 = (Dali::KeyFrames *)jarg1;
42857   arg2 = (float)jarg2;
42858   argp3 = (Dali::Property::Value *)jarg3;
42859   if (!argp3) {
42860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42861     return ;
42862   }
42863   arg3 = *argp3;
42864   argp4 = (Dali::AlphaFunction *)jarg4;
42865   if (!argp4) {
42866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42867     return ;
42868   }
42869   arg4 = *argp4;
42870   {
42871     try {
42872       (arg1)->Add(arg2,arg3,arg4);
42873     } catch (std::out_of_range& e) {
42874       {
42875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42876       };
42877     } catch (std::exception& e) {
42878       {
42879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42880       };
42881     } catch (Dali::DaliException e) {
42882       {
42883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42884       };
42885     } catch (...) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42888       };
42889     }
42890   }
42891
42892 }
42893
42894
42895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42896   int jresult ;
42897   int result;
42898
42899   result = (int)Dali::Path::Property::POINTS;
42900   jresult = (int)result;
42901   return jresult;
42902 }
42903
42904
42905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42906   int jresult ;
42907   int result;
42908
42909   result = (int)Dali::Path::Property::CONTROL_POINTS;
42910   jresult = (int)result;
42911   return jresult;
42912 }
42913
42914
42915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42916   void * jresult ;
42917   Dali::Path::Property *result = 0 ;
42918
42919   {
42920     try {
42921       result = (Dali::Path::Property *)new Dali::Path::Property();
42922     } catch (std::out_of_range& e) {
42923       {
42924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42925       };
42926     } catch (std::exception& e) {
42927       {
42928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (Dali::DaliException e) {
42931       {
42932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42933       };
42934     } catch (...) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42937       };
42938     }
42939   }
42940
42941   jresult = (void *)result;
42942   return jresult;
42943 }
42944
42945
42946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42947   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42948
42949   arg1 = (Dali::Path::Property *)jarg1;
42950   {
42951     try {
42952       delete arg1;
42953     } catch (std::out_of_range& e) {
42954       {
42955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42956       };
42957     } catch (std::exception& e) {
42958       {
42959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42960       };
42961     } catch (Dali::DaliException e) {
42962       {
42963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42964       };
42965     } catch (...) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42968       };
42969     }
42970   }
42971
42972 }
42973
42974
42975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42976   void * jresult ;
42977   Dali::Path result;
42978
42979   {
42980     try {
42981       result = Dali::Path::New();
42982     } catch (std::out_of_range& e) {
42983       {
42984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (std::exception& e) {
42987       {
42988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (Dali::DaliException e) {
42991       {
42992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42993       };
42994     } catch (...) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42997       };
42998     }
42999   }
43000
43001   jresult = new Dali::Path((const Dali::Path &)result);
43002   return jresult;
43003 }
43004
43005
43006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43007   void * jresult ;
43008   Dali::BaseHandle arg1 ;
43009   Dali::BaseHandle *argp1 ;
43010   Dali::Path result;
43011
43012   argp1 = (Dali::BaseHandle *)jarg1;
43013   if (!argp1) {
43014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43015     return 0;
43016   }
43017   arg1 = *argp1;
43018   {
43019     try {
43020       result = Dali::Path::DownCast(arg1);
43021     } catch (std::out_of_range& e) {
43022       {
43023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43024       };
43025     } catch (std::exception& e) {
43026       {
43027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43028       };
43029     } catch (Dali::DaliException e) {
43030       {
43031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43032       };
43033     } catch (...) {
43034       {
43035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43036       };
43037     }
43038   }
43039
43040   jresult = new Dali::Path((const Dali::Path &)result);
43041   return jresult;
43042 }
43043
43044
43045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43046   void * jresult ;
43047   Dali::Path *result = 0 ;
43048
43049   {
43050     try {
43051       result = (Dali::Path *)new Dali::Path();
43052     } catch (std::out_of_range& e) {
43053       {
43054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (std::exception& e) {
43057       {
43058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (Dali::DaliException e) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43063       };
43064     } catch (...) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43067       };
43068     }
43069   }
43070
43071   jresult = (void *)result;
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43077   Dali::Path *arg1 = (Dali::Path *) 0 ;
43078
43079   arg1 = (Dali::Path *)jarg1;
43080   {
43081     try {
43082       delete arg1;
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43098       };
43099     }
43100   }
43101
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43106   void * jresult ;
43107   Dali::Path *arg1 = 0 ;
43108   Dali::Path *result = 0 ;
43109
43110   arg1 = (Dali::Path *)jarg1;
43111   if (!arg1) {
43112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43113     return 0;
43114   }
43115   {
43116     try {
43117       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
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 = (void *)result;
43138   return jresult;
43139 }
43140
43141
43142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43143   void * jresult ;
43144   Dali::Path *arg1 = (Dali::Path *) 0 ;
43145   Dali::Path *arg2 = 0 ;
43146   Dali::Path *result = 0 ;
43147
43148   arg1 = (Dali::Path *)jarg1;
43149   arg2 = (Dali::Path *)jarg2;
43150   if (!arg2) {
43151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43152     return 0;
43153   }
43154   {
43155     try {
43156       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43157     } catch (std::out_of_range& e) {
43158       {
43159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43160       };
43161     } catch (std::exception& e) {
43162       {
43163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43164       };
43165     } catch (Dali::DaliException e) {
43166       {
43167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43168       };
43169     } catch (...) {
43170       {
43171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43172       };
43173     }
43174   }
43175
43176   jresult = (void *)result;
43177   return jresult;
43178 }
43179
43180
43181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43182   Dali::Path *arg1 = (Dali::Path *) 0 ;
43183   Dali::Vector3 *arg2 = 0 ;
43184
43185   arg1 = (Dali::Path *)jarg1;
43186   arg2 = (Dali::Vector3 *)jarg2;
43187   if (!arg2) {
43188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43189     return ;
43190   }
43191   {
43192     try {
43193       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43194     } catch (std::out_of_range& e) {
43195       {
43196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43197       };
43198     } catch (std::exception& e) {
43199       {
43200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43201       };
43202     } catch (Dali::DaliException e) {
43203       {
43204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43205       };
43206     } catch (...) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43209       };
43210     }
43211   }
43212
43213 }
43214
43215
43216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43217   Dali::Path *arg1 = (Dali::Path *) 0 ;
43218   Dali::Vector3 *arg2 = 0 ;
43219
43220   arg1 = (Dali::Path *)jarg1;
43221   arg2 = (Dali::Vector3 *)jarg2;
43222   if (!arg2) {
43223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43224     return ;
43225   }
43226   {
43227     try {
43228       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43229     } catch (std::out_of_range& e) {
43230       {
43231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43232       };
43233     } catch (std::exception& e) {
43234       {
43235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43236       };
43237     } catch (Dali::DaliException e) {
43238       {
43239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43240       };
43241     } catch (...) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43244       };
43245     }
43246   }
43247
43248 }
43249
43250
43251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43252   Dali::Path *arg1 = (Dali::Path *) 0 ;
43253   float arg2 ;
43254
43255   arg1 = (Dali::Path *)jarg1;
43256   arg2 = (float)jarg2;
43257   {
43258     try {
43259       (arg1)->GenerateControlPoints(arg2);
43260     } catch (std::out_of_range& e) {
43261       {
43262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43263       };
43264     } catch (std::exception& e) {
43265       {
43266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43267       };
43268     } catch (Dali::DaliException e) {
43269       {
43270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43271       };
43272     } catch (...) {
43273       {
43274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43275       };
43276     }
43277   }
43278
43279 }
43280
43281
43282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43283   Dali::Path *arg1 = (Dali::Path *) 0 ;
43284   float arg2 ;
43285   Dali::Vector3 *arg3 = 0 ;
43286   Dali::Vector3 *arg4 = 0 ;
43287
43288   arg1 = (Dali::Path *)jarg1;
43289   arg2 = (float)jarg2;
43290   arg3 = (Dali::Vector3 *)jarg3;
43291   if (!arg3) {
43292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43293     return ;
43294   }
43295   arg4 = (Dali::Vector3 *)jarg4;
43296   if (!arg4) {
43297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43298     return ;
43299   }
43300   {
43301     try {
43302       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43303     } catch (std::out_of_range& e) {
43304       {
43305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43306       };
43307     } catch (std::exception& e) {
43308       {
43309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43310       };
43311     } catch (Dali::DaliException e) {
43312       {
43313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43314       };
43315     } catch (...) {
43316       {
43317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43318       };
43319     }
43320   }
43321
43322 }
43323
43324
43325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43326   void * jresult ;
43327   Dali::Path *arg1 = (Dali::Path *) 0 ;
43328   size_t arg2 ;
43329   Dali::Vector3 *result = 0 ;
43330
43331   arg1 = (Dali::Path *)jarg1;
43332   arg2 = (size_t)jarg2;
43333   {
43334     try {
43335       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43336     } catch (std::out_of_range& e) {
43337       {
43338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43339       };
43340     } catch (std::exception& e) {
43341       {
43342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43343       };
43344     } catch (Dali::DaliException e) {
43345       {
43346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43347       };
43348     } catch (...) {
43349       {
43350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43351       };
43352     }
43353   }
43354
43355   jresult = (void *)result;
43356   return jresult;
43357 }
43358
43359
43360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43361   void * jresult ;
43362   Dali::Path *arg1 = (Dali::Path *) 0 ;
43363   size_t arg2 ;
43364   Dali::Vector3 *result = 0 ;
43365
43366   arg1 = (Dali::Path *)jarg1;
43367   arg2 = (size_t)jarg2;
43368   {
43369     try {
43370       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43371     } catch (std::out_of_range& e) {
43372       {
43373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43374       };
43375     } catch (std::exception& e) {
43376       {
43377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43378       };
43379     } catch (Dali::DaliException e) {
43380       {
43381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43382       };
43383     } catch (...) {
43384       {
43385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43386       };
43387     }
43388   }
43389
43390   jresult = (void *)result;
43391   return jresult;
43392 }
43393
43394
43395 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43396   unsigned long jresult ;
43397   Dali::Path *arg1 = (Dali::Path *) 0 ;
43398   size_t result;
43399
43400   arg1 = (Dali::Path *)jarg1;
43401   {
43402     try {
43403       result = ((Dali::Path const *)arg1)->GetPointCount();
43404     } catch (std::out_of_range& e) {
43405       {
43406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43407       };
43408     } catch (std::exception& e) {
43409       {
43410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43411       };
43412     } catch (Dali::DaliException e) {
43413       {
43414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43415       };
43416     } catch (...) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43419       };
43420     }
43421   }
43422
43423   jresult = (unsigned long)result;
43424   return jresult;
43425 }
43426
43427
43428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43429   void * jresult ;
43430   float arg1 ;
43431   Dali::TimePeriod *result = 0 ;
43432
43433   arg1 = (float)jarg1;
43434   {
43435     try {
43436       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43437     } catch (std::out_of_range& e) {
43438       {
43439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43440       };
43441     } catch (std::exception& e) {
43442       {
43443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (Dali::DaliException e) {
43446       {
43447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43448       };
43449     } catch (...) {
43450       {
43451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43452       };
43453     }
43454   }
43455
43456   jresult = (void *)result;
43457   return jresult;
43458 }
43459
43460
43461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43462   void * jresult ;
43463   float arg1 ;
43464   float arg2 ;
43465   Dali::TimePeriod *result = 0 ;
43466
43467   arg1 = (float)jarg1;
43468   arg2 = (float)jarg2;
43469   {
43470     try {
43471       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43472     } catch (std::out_of_range& e) {
43473       {
43474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43475       };
43476     } catch (std::exception& e) {
43477       {
43478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43479       };
43480     } catch (Dali::DaliException e) {
43481       {
43482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43483       };
43484     } catch (...) {
43485       {
43486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43487       };
43488     }
43489   }
43490
43491   jresult = (void *)result;
43492   return jresult;
43493 }
43494
43495
43496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43497   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43498
43499   arg1 = (Dali::TimePeriod *)jarg1;
43500   {
43501     try {
43502       delete arg1;
43503     } catch (std::out_of_range& e) {
43504       {
43505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43506       };
43507     } catch (std::exception& e) {
43508       {
43509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43510       };
43511     } catch (Dali::DaliException e) {
43512       {
43513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43514       };
43515     } catch (...) {
43516       {
43517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43518       };
43519     }
43520   }
43521
43522 }
43523
43524
43525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43526   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43527   float arg2 ;
43528
43529   arg1 = (Dali::TimePeriod *)jarg1;
43530   arg2 = (float)jarg2;
43531   if (arg1) (arg1)->delaySeconds = arg2;
43532 }
43533
43534
43535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43536   float jresult ;
43537   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43538   float result;
43539
43540   arg1 = (Dali::TimePeriod *)jarg1;
43541   result = (float) ((arg1)->delaySeconds);
43542   jresult = result;
43543   return jresult;
43544 }
43545
43546
43547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43548   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43549   float arg2 ;
43550
43551   arg1 = (Dali::TimePeriod *)jarg1;
43552   arg2 = (float)jarg2;
43553   if (arg1) (arg1)->durationSeconds = arg2;
43554 }
43555
43556
43557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43558   float jresult ;
43559   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43560   float result;
43561
43562   arg1 = (Dali::TimePeriod *)jarg1;
43563   result = (float) ((arg1)->durationSeconds);
43564   jresult = result;
43565   return jresult;
43566 }
43567
43568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43569   int jresult ;
43570   int result;
43571
43572   result = (int)Dali::LinearConstrainer::Property::VALUE;
43573   jresult = (int)result;
43574   return jresult;
43575 }
43576
43577
43578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43579   int jresult ;
43580   int result;
43581
43582   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43583   jresult = (int)result;
43584   return jresult;
43585 }
43586
43587
43588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43589   void * jresult ;
43590   Dali::LinearConstrainer::Property *result = 0 ;
43591
43592   {
43593     try {
43594       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43595     } catch (std::out_of_range& e) {
43596       {
43597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43598       };
43599     } catch (std::exception& e) {
43600       {
43601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43602       };
43603     } catch (Dali::DaliException e) {
43604       {
43605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43606       };
43607     } catch (...) {
43608       {
43609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43610       };
43611     }
43612   }
43613
43614   jresult = (void *)result;
43615   return jresult;
43616 }
43617
43618
43619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43620   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43621
43622   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43623   {
43624     try {
43625       delete arg1;
43626     } catch (std::out_of_range& e) {
43627       {
43628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43629       };
43630     } catch (std::exception& e) {
43631       {
43632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43633       };
43634     } catch (Dali::DaliException e) {
43635       {
43636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43637       };
43638     } catch (...) {
43639       {
43640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43641       };
43642     }
43643   }
43644
43645 }
43646
43647
43648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43649   void * jresult ;
43650   Dali::LinearConstrainer result;
43651
43652   {
43653     try {
43654       result = Dali::LinearConstrainer::New();
43655     } catch (std::out_of_range& e) {
43656       {
43657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (std::exception& e) {
43660       {
43661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43662       };
43663     } catch (Dali::DaliException e) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43666       };
43667     } catch (...) {
43668       {
43669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43670       };
43671     }
43672   }
43673
43674   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43675   return jresult;
43676 }
43677
43678
43679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43680   void * jresult ;
43681   Dali::BaseHandle arg1 ;
43682   Dali::BaseHandle *argp1 ;
43683   Dali::LinearConstrainer result;
43684
43685   argp1 = (Dali::BaseHandle *)jarg1;
43686   if (!argp1) {
43687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43688     return 0;
43689   }
43690   arg1 = *argp1;
43691   {
43692     try {
43693       result = Dali::LinearConstrainer::DownCast(arg1);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43701       };
43702     } catch (Dali::DaliException e) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43705       };
43706     } catch (...) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43709       };
43710     }
43711   }
43712
43713   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43714   return jresult;
43715 }
43716
43717
43718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43719   void * jresult ;
43720   Dali::LinearConstrainer *result = 0 ;
43721
43722   {
43723     try {
43724       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43725     } catch (std::out_of_range& e) {
43726       {
43727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (std::exception& e) {
43730       {
43731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43732       };
43733     } catch (Dali::DaliException e) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43736       };
43737     } catch (...) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43740       };
43741     }
43742   }
43743
43744   jresult = (void *)result;
43745   return jresult;
43746 }
43747
43748
43749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43750   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43751
43752   arg1 = (Dali::LinearConstrainer *)jarg1;
43753   {
43754     try {
43755       delete arg1;
43756     } catch (std::out_of_range& e) {
43757       {
43758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43759       };
43760     } catch (std::exception& e) {
43761       {
43762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43763       };
43764     } catch (Dali::DaliException e) {
43765       {
43766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43767       };
43768     } catch (...) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43771       };
43772     }
43773   }
43774
43775 }
43776
43777
43778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43779   void * jresult ;
43780   Dali::LinearConstrainer *arg1 = 0 ;
43781   Dali::LinearConstrainer *result = 0 ;
43782
43783   arg1 = (Dali::LinearConstrainer *)jarg1;
43784   if (!arg1) {
43785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43786     return 0;
43787   }
43788   {
43789     try {
43790       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43791     } catch (std::out_of_range& e) {
43792       {
43793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43794       };
43795     } catch (std::exception& e) {
43796       {
43797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43798       };
43799     } catch (Dali::DaliException e) {
43800       {
43801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43802       };
43803     } catch (...) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43806       };
43807     }
43808   }
43809
43810   jresult = (void *)result;
43811   return jresult;
43812 }
43813
43814
43815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43816   void * jresult ;
43817   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43818   Dali::LinearConstrainer *arg2 = 0 ;
43819   Dali::LinearConstrainer *result = 0 ;
43820
43821   arg1 = (Dali::LinearConstrainer *)jarg1;
43822   arg2 = (Dali::LinearConstrainer *)jarg2;
43823   if (!arg2) {
43824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43825     return 0;
43826   }
43827   {
43828     try {
43829       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43830     } catch (std::out_of_range& e) {
43831       {
43832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43833       };
43834     } catch (std::exception& e) {
43835       {
43836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43837       };
43838     } catch (Dali::DaliException e) {
43839       {
43840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43841       };
43842     } catch (...) {
43843       {
43844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43845       };
43846     }
43847   }
43848
43849   jresult = (void *)result;
43850   return jresult;
43851 }
43852
43853
43854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43855   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43856   SwigValueWrapper< Dali::Property > arg2 ;
43857   SwigValueWrapper< Dali::Property > arg3 ;
43858   Dali::Vector2 *arg4 = 0 ;
43859   Dali::Vector2 *arg5 = 0 ;
43860   Dali::Property *argp2 ;
43861   Dali::Property *argp3 ;
43862
43863   arg1 = (Dali::LinearConstrainer *)jarg1;
43864   argp2 = (Dali::Property *)jarg2;
43865   if (!argp2) {
43866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43867     return ;
43868   }
43869   arg2 = *argp2;
43870   argp3 = (Dali::Property *)jarg3;
43871   if (!argp3) {
43872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43873     return ;
43874   }
43875   arg3 = *argp3;
43876   arg4 = (Dali::Vector2 *)jarg4;
43877   if (!arg4) {
43878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43879     return ;
43880   }
43881   arg5 = (Dali::Vector2 *)jarg5;
43882   if (!arg5) {
43883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43884     return ;
43885   }
43886   {
43887     try {
43888       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43889     } catch (std::out_of_range& e) {
43890       {
43891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43892       };
43893     } catch (std::exception& e) {
43894       {
43895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43896       };
43897     } catch (Dali::DaliException e) {
43898       {
43899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43900       };
43901     } catch (...) {
43902       {
43903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43904       };
43905     }
43906   }
43907
43908 }
43909
43910
43911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43912   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43913   SwigValueWrapper< Dali::Property > arg2 ;
43914   SwigValueWrapper< Dali::Property > arg3 ;
43915   Dali::Vector2 *arg4 = 0 ;
43916   Dali::Property *argp2 ;
43917   Dali::Property *argp3 ;
43918
43919   arg1 = (Dali::LinearConstrainer *)jarg1;
43920   argp2 = (Dali::Property *)jarg2;
43921   if (!argp2) {
43922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43923     return ;
43924   }
43925   arg2 = *argp2;
43926   argp3 = (Dali::Property *)jarg3;
43927   if (!argp3) {
43928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43929     return ;
43930   }
43931   arg3 = *argp3;
43932   arg4 = (Dali::Vector2 *)jarg4;
43933   if (!arg4) {
43934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43935     return ;
43936   }
43937   {
43938     try {
43939       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43940     } catch (std::out_of_range& e) {
43941       {
43942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43943       };
43944     } catch (std::exception& e) {
43945       {
43946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43947       };
43948     } catch (Dali::DaliException e) {
43949       {
43950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43951       };
43952     } catch (...) {
43953       {
43954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43955       };
43956     }
43957   }
43958
43959 }
43960
43961
43962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43963   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43964   Dali::Handle *arg2 = 0 ;
43965
43966   arg1 = (Dali::LinearConstrainer *)jarg1;
43967   arg2 = (Dali::Handle *)jarg2;
43968   if (!arg2) {
43969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43970     return ;
43971   }
43972   {
43973     try {
43974       (arg1)->Remove(*arg2);
43975     } catch (std::out_of_range& e) {
43976       {
43977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43978       };
43979     } catch (std::exception& e) {
43980       {
43981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43982       };
43983     } catch (Dali::DaliException e) {
43984       {
43985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43990       };
43991     }
43992   }
43993
43994 }
43995
43996
43997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43998   int jresult ;
43999   int result;
44000
44001   result = (int)Dali::PathConstrainer::Property::FORWARD;
44002   jresult = (int)result;
44003   return jresult;
44004 }
44005
44006
44007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44008   int jresult ;
44009   int result;
44010
44011   result = (int)Dali::PathConstrainer::Property::POINTS;
44012   jresult = (int)result;
44013   return jresult;
44014 }
44015
44016
44017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44018   int jresult ;
44019   int result;
44020
44021   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44022   jresult = (int)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44028   void * jresult ;
44029   Dali::PathConstrainer::Property *result = 0 ;
44030
44031   {
44032     try {
44033       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44049       };
44050     }
44051   }
44052
44053   jresult = (void *)result;
44054   return jresult;
44055 }
44056
44057
44058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44059   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44060
44061   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44062   {
44063     try {
44064       delete arg1;
44065     } catch (std::out_of_range& e) {
44066       {
44067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44068       };
44069     } catch (std::exception& e) {
44070       {
44071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44072       };
44073     } catch (Dali::DaliException e) {
44074       {
44075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44076       };
44077     } catch (...) {
44078       {
44079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44080       };
44081     }
44082   }
44083
44084 }
44085
44086
44087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44088   void * jresult ;
44089   Dali::PathConstrainer result;
44090
44091   {
44092     try {
44093       result = Dali::PathConstrainer::New();
44094     } catch (std::out_of_range& e) {
44095       {
44096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44097       };
44098     } catch (std::exception& e) {
44099       {
44100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44101       };
44102     } catch (Dali::DaliException e) {
44103       {
44104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44105       };
44106     } catch (...) {
44107       {
44108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44109       };
44110     }
44111   }
44112
44113   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44114   return jresult;
44115 }
44116
44117
44118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44119   void * jresult ;
44120   Dali::BaseHandle arg1 ;
44121   Dali::BaseHandle *argp1 ;
44122   Dali::PathConstrainer result;
44123
44124   argp1 = (Dali::BaseHandle *)jarg1;
44125   if (!argp1) {
44126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44127     return 0;
44128   }
44129   arg1 = *argp1;
44130   {
44131     try {
44132       result = Dali::PathConstrainer::DownCast(arg1);
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44148       };
44149     }
44150   }
44151
44152   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44158   void * jresult ;
44159   Dali::PathConstrainer *result = 0 ;
44160
44161   {
44162     try {
44163       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44164     } catch (std::out_of_range& e) {
44165       {
44166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44167       };
44168     } catch (std::exception& e) {
44169       {
44170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44171       };
44172     } catch (Dali::DaliException e) {
44173       {
44174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44179       };
44180     }
44181   }
44182
44183   jresult = (void *)result;
44184   return jresult;
44185 }
44186
44187
44188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44189   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44190
44191   arg1 = (Dali::PathConstrainer *)jarg1;
44192   {
44193     try {
44194       delete arg1;
44195     } catch (std::out_of_range& e) {
44196       {
44197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44198       };
44199     } catch (std::exception& e) {
44200       {
44201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44202       };
44203     } catch (Dali::DaliException e) {
44204       {
44205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44210       };
44211     }
44212   }
44213
44214 }
44215
44216
44217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44218   void * jresult ;
44219   Dali::PathConstrainer *arg1 = 0 ;
44220   Dali::PathConstrainer *result = 0 ;
44221
44222   arg1 = (Dali::PathConstrainer *)jarg1;
44223   if (!arg1) {
44224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44225     return 0;
44226   }
44227   {
44228     try {
44229       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44230     } catch (std::out_of_range& e) {
44231       {
44232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44233       };
44234     } catch (std::exception& e) {
44235       {
44236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44237       };
44238     } catch (Dali::DaliException e) {
44239       {
44240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44241       };
44242     } catch (...) {
44243       {
44244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44245       };
44246     }
44247   }
44248
44249   jresult = (void *)result;
44250   return jresult;
44251 }
44252
44253
44254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44255   void * jresult ;
44256   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44257   Dali::PathConstrainer *arg2 = 0 ;
44258   Dali::PathConstrainer *result = 0 ;
44259
44260   arg1 = (Dali::PathConstrainer *)jarg1;
44261   arg2 = (Dali::PathConstrainer *)jarg2;
44262   if (!arg2) {
44263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44264     return 0;
44265   }
44266   {
44267     try {
44268       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44269     } catch (std::out_of_range& e) {
44270       {
44271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44272       };
44273     } catch (std::exception& e) {
44274       {
44275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44276       };
44277     } catch (Dali::DaliException e) {
44278       {
44279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44280       };
44281     } catch (...) {
44282       {
44283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44284       };
44285     }
44286   }
44287
44288   jresult = (void *)result;
44289   return jresult;
44290 }
44291
44292
44293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44294   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44295   SwigValueWrapper< Dali::Property > arg2 ;
44296   SwigValueWrapper< Dali::Property > arg3 ;
44297   Dali::Vector2 *arg4 = 0 ;
44298   Dali::Vector2 *arg5 = 0 ;
44299   Dali::Property *argp2 ;
44300   Dali::Property *argp3 ;
44301
44302   arg1 = (Dali::PathConstrainer *)jarg1;
44303   argp2 = (Dali::Property *)jarg2;
44304   if (!argp2) {
44305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44306     return ;
44307   }
44308   arg2 = *argp2;
44309   argp3 = (Dali::Property *)jarg3;
44310   if (!argp3) {
44311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44312     return ;
44313   }
44314   arg3 = *argp3;
44315   arg4 = (Dali::Vector2 *)jarg4;
44316   if (!arg4) {
44317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44318     return ;
44319   }
44320   arg5 = (Dali::Vector2 *)jarg5;
44321   if (!arg5) {
44322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44323     return ;
44324   }
44325   {
44326     try {
44327       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44328     } catch (std::out_of_range& e) {
44329       {
44330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (std::exception& e) {
44333       {
44334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44335       };
44336     } catch (Dali::DaliException e) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44339       };
44340     } catch (...) {
44341       {
44342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44343       };
44344     }
44345   }
44346
44347 }
44348
44349
44350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44351   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44352   SwigValueWrapper< Dali::Property > arg2 ;
44353   SwigValueWrapper< Dali::Property > arg3 ;
44354   Dali::Vector2 *arg4 = 0 ;
44355   Dali::Property *argp2 ;
44356   Dali::Property *argp3 ;
44357
44358   arg1 = (Dali::PathConstrainer *)jarg1;
44359   argp2 = (Dali::Property *)jarg2;
44360   if (!argp2) {
44361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44362     return ;
44363   }
44364   arg2 = *argp2;
44365   argp3 = (Dali::Property *)jarg3;
44366   if (!argp3) {
44367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44368     return ;
44369   }
44370   arg3 = *argp3;
44371   arg4 = (Dali::Vector2 *)jarg4;
44372   if (!arg4) {
44373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44374     return ;
44375   }
44376   {
44377     try {
44378       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44379     } catch (std::out_of_range& e) {
44380       {
44381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44382       };
44383     } catch (std::exception& e) {
44384       {
44385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (Dali::DaliException e) {
44388       {
44389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44390       };
44391     } catch (...) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44394       };
44395     }
44396   }
44397
44398 }
44399
44400
44401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44402   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44403   Dali::Handle *arg2 = 0 ;
44404
44405   arg1 = (Dali::PathConstrainer *)jarg1;
44406   arg2 = (Dali::Handle *)jarg2;
44407   if (!arg2) {
44408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44409     return ;
44410   }
44411   {
44412     try {
44413       (arg1)->Remove(*arg2);
44414     } catch (std::out_of_range& e) {
44415       {
44416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44417       };
44418     } catch (std::exception& e) {
44419       {
44420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44421       };
44422     } catch (Dali::DaliException e) {
44423       {
44424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44425       };
44426     } catch (...) {
44427       {
44428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44429       };
44430     }
44431   }
44432
44433 }
44434
44435
44436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44437   int jresult ;
44438   Dali::FittingMode::Type result;
44439
44440   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44441   jresult = (int)result;
44442   return jresult;
44443 }
44444
44445
44446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44447   int jresult ;
44448   Dali::SamplingMode::Type result;
44449
44450   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44451   jresult = (int)result;
44452   return jresult;
44453 }
44454
44455
44456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44457   unsigned int jresult ;
44458   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44459   bool result;
44460
44461   arg1 = (Dali::NativeImageInterface *)jarg1;
44462   {
44463     try {
44464       result = (bool)(arg1)->CreateResource();
44465     } catch (std::out_of_range& e) {
44466       {
44467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44468       };
44469     } catch (std::exception& e) {
44470       {
44471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44472       };
44473     } catch (Dali::DaliException e) {
44474       {
44475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44476       };
44477     } catch (...) {
44478       {
44479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44480       };
44481     }
44482   }
44483
44484   jresult = result;
44485   return jresult;
44486 }
44487
44488
44489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44490   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44491
44492   arg1 = (Dali::NativeImageInterface *)jarg1;
44493   {
44494     try {
44495       (arg1)->DestroyResource();
44496     } catch (std::out_of_range& e) {
44497       {
44498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44499       };
44500     } catch (std::exception& e) {
44501       {
44502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44503       };
44504     } catch (Dali::DaliException e) {
44505       {
44506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44507       };
44508     } catch (...) {
44509       {
44510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44511       };
44512     }
44513   }
44514
44515 }
44516
44517
44518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44519   unsigned int jresult ;
44520   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44521   unsigned int result;
44522
44523   arg1 = (Dali::NativeImageInterface *)jarg1;
44524   {
44525     try {
44526       result = (unsigned int)(arg1)->TargetTexture();
44527     } catch (std::out_of_range& e) {
44528       {
44529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44530       };
44531     } catch (std::exception& e) {
44532       {
44533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44534       };
44535     } catch (Dali::DaliException e) {
44536       {
44537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44538       };
44539     } catch (...) {
44540       {
44541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44542       };
44543     }
44544   }
44545
44546   jresult = result;
44547   return jresult;
44548 }
44549
44550
44551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44552   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44553
44554   arg1 = (Dali::NativeImageInterface *)jarg1;
44555   {
44556     try {
44557       (arg1)->PrepareTexture();
44558     } catch (std::out_of_range& e) {
44559       {
44560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44561       };
44562     } catch (std::exception& e) {
44563       {
44564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44565       };
44566     } catch (Dali::DaliException e) {
44567       {
44568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44569       };
44570     } catch (...) {
44571       {
44572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44573       };
44574     }
44575   }
44576
44577 }
44578
44579
44580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44581   unsigned int jresult ;
44582   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44583   unsigned int result;
44584
44585   arg1 = (Dali::NativeImageInterface *)jarg1;
44586   {
44587     try {
44588       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44589     } catch (std::out_of_range& e) {
44590       {
44591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44592       };
44593     } catch (std::exception& e) {
44594       {
44595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44596       };
44597     } catch (Dali::DaliException e) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44600       };
44601     } catch (...) {
44602       {
44603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44604       };
44605     }
44606   }
44607
44608   jresult = result;
44609   return jresult;
44610 }
44611
44612
44613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44614   unsigned int jresult ;
44615   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44616   unsigned int result;
44617
44618   arg1 = (Dali::NativeImageInterface *)jarg1;
44619   {
44620     try {
44621       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44622     } catch (std::out_of_range& e) {
44623       {
44624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44625       };
44626     } catch (std::exception& e) {
44627       {
44628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44629       };
44630     } catch (Dali::DaliException e) {
44631       {
44632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44633       };
44634     } catch (...) {
44635       {
44636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44637       };
44638     }
44639   }
44640
44641   jresult = result;
44642   return jresult;
44643 }
44644
44645
44646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44647   unsigned int jresult ;
44648   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44649   bool result;
44650
44651   arg1 = (Dali::NativeImageInterface *)jarg1;
44652   {
44653     try {
44654       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (Dali::DaliException e) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44666       };
44667     } catch (...) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44670       };
44671     }
44672   }
44673
44674   jresult = result;
44675   return jresult;
44676 }
44677
44678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44679   int jresult ;
44680   int result;
44681
44682   result = (int)Dali::CameraActor::Property::TYPE;
44683   jresult = (int)result;
44684   return jresult;
44685 }
44686
44687
44688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44689   int jresult ;
44690   int result;
44691
44692   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44693   jresult = (int)result;
44694   return jresult;
44695 }
44696
44697
44698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44699   int jresult ;
44700   int result;
44701
44702   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44703   jresult = (int)result;
44704   return jresult;
44705 }
44706
44707
44708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44709   int jresult ;
44710   int result;
44711
44712   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44713   jresult = (int)result;
44714   return jresult;
44715 }
44716
44717
44718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44719   int jresult ;
44720   int result;
44721
44722   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44723   jresult = (int)result;
44724   return jresult;
44725 }
44726
44727
44728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44729   int jresult ;
44730   int result;
44731
44732   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44733   jresult = (int)result;
44734   return jresult;
44735 }
44736
44737
44738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44739   int jresult ;
44740   int result;
44741
44742   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44743   jresult = (int)result;
44744   return jresult;
44745 }
44746
44747
44748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44749   int jresult ;
44750   int result;
44751
44752   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44753   jresult = (int)result;
44754   return jresult;
44755 }
44756
44757
44758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44759   int jresult ;
44760   int result;
44761
44762   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44763   jresult = (int)result;
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44769   int jresult ;
44770   int result;
44771
44772   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44773   jresult = (int)result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44779   int jresult ;
44780   int result;
44781
44782   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44783   jresult = (int)result;
44784   return jresult;
44785 }
44786
44787
44788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44789   int jresult ;
44790   int result;
44791
44792   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44793   jresult = (int)result;
44794   return jresult;
44795 }
44796
44797
44798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44799   int jresult ;
44800   int result;
44801
44802   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44803   jresult = (int)result;
44804   return jresult;
44805 }
44806
44807
44808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44809   int jresult ;
44810   int result;
44811
44812   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44813   jresult = (int)result;
44814   return jresult;
44815 }
44816
44817
44818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44819   void * jresult ;
44820   Dali::CameraActor::Property *result = 0 ;
44821
44822   {
44823     try {
44824       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44832       };
44833     } catch (Dali::DaliException e) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44836       };
44837     } catch (...) {
44838       {
44839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44840       };
44841     }
44842   }
44843
44844   jresult = (void *)result;
44845   return jresult;
44846 }
44847
44848
44849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44850   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44851
44852   arg1 = (Dali::CameraActor::Property *)jarg1;
44853   {
44854     try {
44855       delete arg1;
44856     } catch (std::out_of_range& e) {
44857       {
44858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44859       };
44860     } catch (std::exception& e) {
44861       {
44862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44863       };
44864     } catch (Dali::DaliException e) {
44865       {
44866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44867       };
44868     } catch (...) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44871       };
44872     }
44873   }
44874
44875 }
44876
44877
44878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44879   void * jresult ;
44880   Dali::CameraActor *result = 0 ;
44881
44882   {
44883     try {
44884       result = (Dali::CameraActor *)new Dali::CameraActor();
44885     } catch (std::out_of_range& e) {
44886       {
44887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44888       };
44889     } catch (std::exception& e) {
44890       {
44891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44892       };
44893     } catch (Dali::DaliException e) {
44894       {
44895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44896       };
44897     } catch (...) {
44898       {
44899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44900       };
44901     }
44902   }
44903
44904   jresult = (void *)result;
44905   return jresult;
44906 }
44907
44908
44909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44910   void * jresult ;
44911   Dali::CameraActor result;
44912
44913   {
44914     try {
44915       result = Dali::CameraActor::New();
44916     } catch (std::out_of_range& e) {
44917       {
44918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44919       };
44920     } catch (std::exception& e) {
44921       {
44922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44923       };
44924     } catch (Dali::DaliException e) {
44925       {
44926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44927       };
44928     } catch (...) {
44929       {
44930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44931       };
44932     }
44933   }
44934
44935   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44936   return jresult;
44937 }
44938
44939
44940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44941   void * jresult ;
44942   Dali::Size *arg1 = 0 ;
44943   Dali::CameraActor result;
44944
44945   arg1 = (Dali::Size *)jarg1;
44946   if (!arg1) {
44947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44948     return 0;
44949   }
44950   {
44951     try {
44952       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44953     } catch (std::out_of_range& e) {
44954       {
44955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44956       };
44957     } catch (std::exception& e) {
44958       {
44959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44960       };
44961     } catch (Dali::DaliException e) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44964       };
44965     } catch (...) {
44966       {
44967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44968       };
44969     }
44970   }
44971
44972   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44973   return jresult;
44974 }
44975
44976
44977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44978   void * jresult ;
44979   Dali::BaseHandle arg1 ;
44980   Dali::BaseHandle *argp1 ;
44981   Dali::CameraActor result;
44982
44983   argp1 = (Dali::BaseHandle *)jarg1;
44984   if (!argp1) {
44985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44986     return 0;
44987   }
44988   arg1 = *argp1;
44989   {
44990     try {
44991       result = Dali::CameraActor::DownCast(arg1);
44992     } catch (std::out_of_range& e) {
44993       {
44994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44995       };
44996     } catch (std::exception& e) {
44997       {
44998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44999       };
45000     } catch (Dali::DaliException e) {
45001       {
45002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45003       };
45004     } catch (...) {
45005       {
45006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45007       };
45008     }
45009   }
45010
45011   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45012   return jresult;
45013 }
45014
45015
45016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45017   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45018
45019   arg1 = (Dali::CameraActor *)jarg1;
45020   {
45021     try {
45022       delete arg1;
45023     } catch (std::out_of_range& e) {
45024       {
45025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45026       };
45027     } catch (std::exception& e) {
45028       {
45029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45030       };
45031     } catch (Dali::DaliException e) {
45032       {
45033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45034       };
45035     } catch (...) {
45036       {
45037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45038       };
45039     }
45040   }
45041
45042 }
45043
45044
45045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45046   void * jresult ;
45047   Dali::CameraActor *arg1 = 0 ;
45048   Dali::CameraActor *result = 0 ;
45049
45050   arg1 = (Dali::CameraActor *)jarg1;
45051   if (!arg1) {
45052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45053     return 0;
45054   }
45055   {
45056     try {
45057       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45058     } catch (std::out_of_range& e) {
45059       {
45060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45061       };
45062     } catch (std::exception& e) {
45063       {
45064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45065       };
45066     } catch (Dali::DaliException e) {
45067       {
45068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45069       };
45070     } catch (...) {
45071       {
45072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45073       };
45074     }
45075   }
45076
45077   jresult = (void *)result;
45078   return jresult;
45079 }
45080
45081
45082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45083   void * jresult ;
45084   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45085   Dali::CameraActor *arg2 = 0 ;
45086   Dali::CameraActor *result = 0 ;
45087
45088   arg1 = (Dali::CameraActor *)jarg1;
45089   arg2 = (Dali::CameraActor *)jarg2;
45090   if (!arg2) {
45091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45092     return 0;
45093   }
45094   {
45095     try {
45096       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45097     } catch (std::out_of_range& e) {
45098       {
45099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45100       };
45101     } catch (std::exception& e) {
45102       {
45103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45104       };
45105     } catch (Dali::DaliException e) {
45106       {
45107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45112       };
45113     }
45114   }
45115
45116   jresult = (void *)result;
45117   return jresult;
45118 }
45119
45120
45121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45122   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45123   Dali::Camera::Type arg2 ;
45124
45125   arg1 = (Dali::CameraActor *)jarg1;
45126   arg2 = (Dali::Camera::Type)jarg2;
45127   {
45128     try {
45129       (arg1)->SetType(arg2);
45130     } catch (std::out_of_range& e) {
45131       {
45132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45133       };
45134     } catch (std::exception& e) {
45135       {
45136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45137       };
45138     } catch (Dali::DaliException e) {
45139       {
45140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45141       };
45142     } catch (...) {
45143       {
45144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45145       };
45146     }
45147   }
45148
45149 }
45150
45151
45152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45153   int jresult ;
45154   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45155   Dali::Camera::Type result;
45156
45157   arg1 = (Dali::CameraActor *)jarg1;
45158   {
45159     try {
45160       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45161     } catch (std::out_of_range& e) {
45162       {
45163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45164       };
45165     } catch (std::exception& e) {
45166       {
45167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45168       };
45169     } catch (Dali::DaliException e) {
45170       {
45171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45172       };
45173     } catch (...) {
45174       {
45175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45176       };
45177     }
45178   }
45179
45180   jresult = (int)result;
45181   return jresult;
45182 }
45183
45184
45185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45186   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45187   Dali::Camera::ProjectionMode arg2 ;
45188
45189   arg1 = (Dali::CameraActor *)jarg1;
45190   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45191   {
45192     try {
45193       (arg1)->SetProjectionMode(arg2);
45194     } catch (std::out_of_range& e) {
45195       {
45196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45197       };
45198     } catch (std::exception& e) {
45199       {
45200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45201       };
45202     } catch (Dali::DaliException e) {
45203       {
45204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45209       };
45210     }
45211   }
45212
45213 }
45214
45215
45216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45217   int jresult ;
45218   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45219   Dali::Camera::ProjectionMode result;
45220
45221   arg1 = (Dali::CameraActor *)jarg1;
45222   {
45223     try {
45224       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45225     } catch (std::out_of_range& e) {
45226       {
45227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45228       };
45229     } catch (std::exception& e) {
45230       {
45231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45232       };
45233     } catch (Dali::DaliException e) {
45234       {
45235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45236       };
45237     } catch (...) {
45238       {
45239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45240       };
45241     }
45242   }
45243
45244   jresult = (int)result;
45245   return jresult;
45246 }
45247
45248
45249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45250   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45251   float arg2 ;
45252
45253   arg1 = (Dali::CameraActor *)jarg1;
45254   arg2 = (float)jarg2;
45255   {
45256     try {
45257       (arg1)->SetFieldOfView(arg2);
45258     } catch (std::out_of_range& e) {
45259       {
45260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45261       };
45262     } catch (std::exception& e) {
45263       {
45264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45265       };
45266     } catch (Dali::DaliException e) {
45267       {
45268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45269       };
45270     } catch (...) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45273       };
45274     }
45275   }
45276
45277 }
45278
45279
45280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45281   float jresult ;
45282   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45283   float result;
45284
45285   arg1 = (Dali::CameraActor *)jarg1;
45286   {
45287     try {
45288       result = (float)(arg1)->GetFieldOfView();
45289     } catch (std::out_of_range& e) {
45290       {
45291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45292       };
45293     } catch (std::exception& e) {
45294       {
45295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45296       };
45297     } catch (Dali::DaliException e) {
45298       {
45299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45300       };
45301     } catch (...) {
45302       {
45303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45304       };
45305     }
45306   }
45307
45308   jresult = result;
45309   return jresult;
45310 }
45311
45312
45313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45314   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45315   float arg2 ;
45316
45317   arg1 = (Dali::CameraActor *)jarg1;
45318   arg2 = (float)jarg2;
45319   {
45320     try {
45321       (arg1)->SetAspectRatio(arg2);
45322     } catch (std::out_of_range& e) {
45323       {
45324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45325       };
45326     } catch (std::exception& e) {
45327       {
45328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45329       };
45330     } catch (Dali::DaliException e) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45333       };
45334     } catch (...) {
45335       {
45336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45337       };
45338     }
45339   }
45340
45341 }
45342
45343
45344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45345   float jresult ;
45346   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45347   float result;
45348
45349   arg1 = (Dali::CameraActor *)jarg1;
45350   {
45351     try {
45352       result = (float)(arg1)->GetAspectRatio();
45353     } catch (std::out_of_range& e) {
45354       {
45355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45356       };
45357     } catch (std::exception& e) {
45358       {
45359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45360       };
45361     } catch (Dali::DaliException e) {
45362       {
45363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45364       };
45365     } catch (...) {
45366       {
45367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45368       };
45369     }
45370   }
45371
45372   jresult = result;
45373   return jresult;
45374 }
45375
45376
45377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45378   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45379   float arg2 ;
45380
45381   arg1 = (Dali::CameraActor *)jarg1;
45382   arg2 = (float)jarg2;
45383   {
45384     try {
45385       (arg1)->SetNearClippingPlane(arg2);
45386     } catch (std::out_of_range& e) {
45387       {
45388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45389       };
45390     } catch (std::exception& e) {
45391       {
45392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45393       };
45394     } catch (Dali::DaliException e) {
45395       {
45396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45397       };
45398     } catch (...) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45401       };
45402     }
45403   }
45404
45405 }
45406
45407
45408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45409   float jresult ;
45410   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45411   float result;
45412
45413   arg1 = (Dali::CameraActor *)jarg1;
45414   {
45415     try {
45416       result = (float)(arg1)->GetNearClippingPlane();
45417     } catch (std::out_of_range& e) {
45418       {
45419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45420       };
45421     } catch (std::exception& e) {
45422       {
45423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45424       };
45425     } catch (Dali::DaliException e) {
45426       {
45427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45428       };
45429     } catch (...) {
45430       {
45431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45432       };
45433     }
45434   }
45435
45436   jresult = result;
45437   return jresult;
45438 }
45439
45440
45441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45442   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45443   float arg2 ;
45444
45445   arg1 = (Dali::CameraActor *)jarg1;
45446   arg2 = (float)jarg2;
45447   {
45448     try {
45449       (arg1)->SetFarClippingPlane(arg2);
45450     } catch (std::out_of_range& e) {
45451       {
45452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45453       };
45454     } catch (std::exception& e) {
45455       {
45456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45457       };
45458     } catch (Dali::DaliException e) {
45459       {
45460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45461       };
45462     } catch (...) {
45463       {
45464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45465       };
45466     }
45467   }
45468
45469 }
45470
45471
45472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45473   float jresult ;
45474   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45475   float result;
45476
45477   arg1 = (Dali::CameraActor *)jarg1;
45478   {
45479     try {
45480       result = (float)(arg1)->GetFarClippingPlane();
45481     } catch (std::out_of_range& e) {
45482       {
45483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45484       };
45485     } catch (std::exception& e) {
45486       {
45487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45488       };
45489     } catch (Dali::DaliException e) {
45490       {
45491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45492       };
45493     } catch (...) {
45494       {
45495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45496       };
45497     }
45498   }
45499
45500   jresult = result;
45501   return jresult;
45502 }
45503
45504
45505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45506   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45507   Dali::Vector3 *arg2 = 0 ;
45508
45509   arg1 = (Dali::CameraActor *)jarg1;
45510   arg2 = (Dali::Vector3 *)jarg2;
45511   if (!arg2) {
45512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45513     return ;
45514   }
45515   {
45516     try {
45517       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45518     } catch (std::out_of_range& e) {
45519       {
45520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45521       };
45522     } catch (std::exception& e) {
45523       {
45524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45525       };
45526     } catch (Dali::DaliException e) {
45527       {
45528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45529       };
45530     } catch (...) {
45531       {
45532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45533       };
45534     }
45535   }
45536
45537 }
45538
45539
45540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45541   void * jresult ;
45542   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45543   Dali::Vector3 result;
45544
45545   arg1 = (Dali::CameraActor *)jarg1;
45546   {
45547     try {
45548       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45549     } catch (std::out_of_range& e) {
45550       {
45551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45552       };
45553     } catch (std::exception& e) {
45554       {
45555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45556       };
45557     } catch (Dali::DaliException e) {
45558       {
45559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45560       };
45561     } catch (...) {
45562       {
45563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45564       };
45565     }
45566   }
45567
45568   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45569   return jresult;
45570 }
45571
45572
45573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45574   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45575   bool arg2 ;
45576
45577   arg1 = (Dali::CameraActor *)jarg1;
45578   arg2 = jarg2 ? true : false;
45579   {
45580     try {
45581       (arg1)->SetInvertYAxis(arg2);
45582     } catch (std::out_of_range& e) {
45583       {
45584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45585       };
45586     } catch (std::exception& e) {
45587       {
45588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45589       };
45590     } catch (Dali::DaliException e) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45593       };
45594     } catch (...) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45597       };
45598     }
45599   }
45600
45601 }
45602
45603
45604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45605   unsigned int jresult ;
45606   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45607   bool result;
45608
45609   arg1 = (Dali::CameraActor *)jarg1;
45610   {
45611     try {
45612       result = (bool)(arg1)->GetInvertYAxis();
45613     } catch (std::out_of_range& e) {
45614       {
45615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45616       };
45617     } catch (std::exception& e) {
45618       {
45619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45620       };
45621     } catch (Dali::DaliException e) {
45622       {
45623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45628       };
45629     }
45630   }
45631
45632   jresult = result;
45633   return jresult;
45634 }
45635
45636
45637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45638   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45639   Dali::Size *arg2 = 0 ;
45640
45641   arg1 = (Dali::CameraActor *)jarg1;
45642   arg2 = (Dali::Size *)jarg2;
45643   if (!arg2) {
45644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45645     return ;
45646   }
45647   {
45648     try {
45649       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45650     } catch (std::out_of_range& e) {
45651       {
45652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45653       };
45654     } catch (std::exception& e) {
45655       {
45656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45657       };
45658     } catch (Dali::DaliException e) {
45659       {
45660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45661       };
45662     } catch (...) {
45663       {
45664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45665       };
45666     }
45667   }
45668
45669 }
45670
45671
45672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45673   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45674   Dali::Size *arg2 = 0 ;
45675
45676   arg1 = (Dali::CameraActor *)jarg1;
45677   arg2 = (Dali::Size *)jarg2;
45678   if (!arg2) {
45679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45680     return ;
45681   }
45682   {
45683     try {
45684       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45685     } catch (std::out_of_range& e) {
45686       {
45687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45688       };
45689     } catch (std::exception& e) {
45690       {
45691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45692       };
45693     } catch (Dali::DaliException e) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45696       };
45697     } catch (...) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45700       };
45701     }
45702   }
45703
45704 }
45705
45706
45707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45708   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45709   float arg2 ;
45710   float arg3 ;
45711   float arg4 ;
45712   float arg5 ;
45713   float arg6 ;
45714   float arg7 ;
45715
45716   arg1 = (Dali::CameraActor *)jarg1;
45717   arg2 = (float)jarg2;
45718   arg3 = (float)jarg3;
45719   arg4 = (float)jarg4;
45720   arg5 = (float)jarg5;
45721   arg6 = (float)jarg6;
45722   arg7 = (float)jarg7;
45723   {
45724     try {
45725       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45726     } catch (std::out_of_range& e) {
45727       {
45728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45729       };
45730     } catch (std::exception& e) {
45731       {
45732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45733       };
45734     } catch (Dali::DaliException e) {
45735       {
45736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45737       };
45738     } catch (...) {
45739       {
45740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45741       };
45742     }
45743   }
45744
45745 }
45746
45747
45748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45749   void * jresult ;
45750   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45751
45752   {
45753     try {
45754       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45755     } catch (std::out_of_range& e) {
45756       {
45757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (std::exception& e) {
45760       {
45761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45762       };
45763     } catch (Dali::DaliException e) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45766       };
45767     } catch (...) {
45768       {
45769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45770       };
45771     }
45772   }
45773
45774   jresult = (void *)result;
45775   return jresult;
45776 }
45777
45778
45779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45780   void * jresult ;
45781   std::string arg1 ;
45782   Dali::Property::Value arg2 ;
45783   Dali::Property::Value *argp2 ;
45784   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45785
45786   if (!jarg1) {
45787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45788     return 0;
45789   }
45790   (&arg1)->assign(jarg1);
45791   argp2 = (Dali::Property::Value *)jarg2;
45792   if (!argp2) {
45793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45794     return 0;
45795   }
45796   arg2 = *argp2;
45797   {
45798     try {
45799       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (Dali::DaliException e) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45811       };
45812     } catch (...) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45815       };
45816     }
45817   }
45818
45819   jresult = (void *)result;
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45825   void * jresult ;
45826   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45827   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45828
45829   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45830   if (!arg1) {
45831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45832     return 0;
45833   }
45834   {
45835     try {
45836       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);
45837     } catch (std::out_of_range& e) {
45838       {
45839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45840       };
45841     } catch (std::exception& e) {
45842       {
45843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (Dali::DaliException e) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45848       };
45849     } catch (...) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45852       };
45853     }
45854   }
45855
45856   jresult = (void *)result;
45857   return jresult;
45858 }
45859
45860
45861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45862   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45863   std::string *arg2 = 0 ;
45864
45865   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45866   if (!jarg2) {
45867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45868     return ;
45869   }
45870   std::string arg2_str(jarg2);
45871   arg2 = &arg2_str;
45872   if (arg1) (arg1)->first = *arg2;
45873
45874   //argout typemap for const std::string&
45875
45876 }
45877
45878
45879 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45880   char * jresult ;
45881   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45882   std::string *result = 0 ;
45883
45884   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45885   result = (std::string *) & ((arg1)->first);
45886   jresult = SWIG_csharp_string_callback(result->c_str());
45887   return jresult;
45888 }
45889
45890
45891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45892   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45893   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45894
45895   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45896   arg2 = (Dali::Property::Value *)jarg2;
45897   if (arg1) (arg1)->second = *arg2;
45898 }
45899
45900
45901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45902   void * jresult ;
45903   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45904   Dali::Property::Value *result = 0 ;
45905
45906   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45907   result = (Dali::Property::Value *)& ((arg1)->second);
45908   jresult = (void *)result;
45909   return jresult;
45910 }
45911
45912
45913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45914   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45915
45916   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45917   {
45918     try {
45919       delete arg1;
45920     } catch (std::out_of_range& e) {
45921       {
45922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45923       };
45924     } catch (std::exception& e) {
45925       {
45926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45927       };
45928     } catch (Dali::DaliException e) {
45929       {
45930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45931       };
45932     } catch (...) {
45933       {
45934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45935       };
45936     }
45937   }
45938
45939 }
45940
45941
45942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45943   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45944
45945   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45946   {
45947     try {
45948       (arg1)->clear();
45949     } catch (std::out_of_range& e) {
45950       {
45951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45952       };
45953     } catch (std::exception& e) {
45954       {
45955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45956       };
45957     } catch (Dali::DaliException e) {
45958       {
45959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45960       };
45961     } catch (...) {
45962       {
45963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45964       };
45965     }
45966   }
45967
45968 }
45969
45970
45971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45972   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45973   Dali::TouchPoint *arg2 = 0 ;
45974
45975   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45976   arg2 = (Dali::TouchPoint *)jarg2;
45977   if (!arg2) {
45978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45979     return ;
45980   }
45981   {
45982     try {
45983       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45984     } catch (std::out_of_range& e) {
45985       {
45986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45987       };
45988     } catch (std::exception& e) {
45989       {
45990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45991       };
45992     } catch (Dali::DaliException e) {
45993       {
45994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45995       };
45996     } catch (...) {
45997       {
45998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45999       };
46000     }
46001   }
46002
46003 }
46004
46005
46006 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46007   unsigned long jresult ;
46008   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46009   std::vector< Dali::TouchPoint >::size_type result;
46010
46011   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46012   {
46013     try {
46014       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46015     } catch (std::out_of_range& e) {
46016       {
46017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46018       };
46019     } catch (std::exception& e) {
46020       {
46021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46022       };
46023     } catch (Dali::DaliException e) {
46024       {
46025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46026       };
46027     } catch (...) {
46028       {
46029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46030       };
46031     }
46032   }
46033
46034   jresult = (unsigned long)result;
46035   return jresult;
46036 }
46037
46038
46039 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46040   unsigned long jresult ;
46041   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46042   std::vector< Dali::TouchPoint >::size_type result;
46043
46044   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46045   {
46046     try {
46047       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46048     } catch (std::out_of_range& e) {
46049       {
46050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46051       };
46052     } catch (std::exception& e) {
46053       {
46054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46055       };
46056     } catch (Dali::DaliException e) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46059       };
46060     } catch (...) {
46061       {
46062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46063       };
46064     }
46065   }
46066
46067   jresult = (unsigned long)result;
46068   return jresult;
46069 }
46070
46071
46072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46073   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46074   std::vector< Dali::TouchPoint >::size_type arg2 ;
46075
46076   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46077   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46078   {
46079     try {
46080       (arg1)->reserve(arg2);
46081     } catch (std::out_of_range& e) {
46082       {
46083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46084       };
46085     } catch (std::exception& e) {
46086       {
46087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46088       };
46089     } catch (Dali::DaliException e) {
46090       {
46091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46092       };
46093     } catch (...) {
46094       {
46095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46096       };
46097     }
46098   }
46099
46100 }
46101
46102
46103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46104   void * jresult ;
46105   std::vector< Dali::TouchPoint > *result = 0 ;
46106
46107   {
46108     try {
46109       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46110     } catch (std::out_of_range& e) {
46111       {
46112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46113       };
46114     } catch (std::exception& e) {
46115       {
46116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46117       };
46118     } catch (Dali::DaliException e) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46121       };
46122     } catch (...) {
46123       {
46124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46125       };
46126     }
46127   }
46128
46129   jresult = (void *)result;
46130   return jresult;
46131 }
46132
46133
46134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46135   void * jresult ;
46136   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46137   std::vector< Dali::TouchPoint > *result = 0 ;
46138
46139   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46140   if (!arg1) {
46141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46142     return 0;
46143   }
46144   {
46145     try {
46146       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46147     } catch (std::out_of_range& e) {
46148       {
46149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46150       };
46151     } catch (std::exception& e) {
46152       {
46153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46154       };
46155     } catch (Dali::DaliException e) {
46156       {
46157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46158       };
46159     } catch (...) {
46160       {
46161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46162       };
46163     }
46164   }
46165
46166   jresult = (void *)result;
46167   return jresult;
46168 }
46169
46170
46171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46172   void * jresult ;
46173   int arg1 ;
46174   std::vector< Dali::TouchPoint > *result = 0 ;
46175
46176   arg1 = (int)jarg1;
46177   {
46178     try {
46179       try {
46180         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46181       }
46182       catch(std::out_of_range &_e) {
46183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46184         return 0;
46185       }
46186
46187     } catch (std::out_of_range& e) {
46188       {
46189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46190       };
46191     } catch (std::exception& e) {
46192       {
46193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46194       };
46195     } catch (Dali::DaliException e) {
46196       {
46197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46198       };
46199     } catch (...) {
46200       {
46201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46202       };
46203     }
46204   }
46205
46206   jresult = (void *)result;
46207   return jresult;
46208 }
46209
46210
46211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46212   void * jresult ;
46213   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46214   int arg2 ;
46215   SwigValueWrapper< Dali::TouchPoint > result;
46216
46217   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46218   arg2 = (int)jarg2;
46219   {
46220     try {
46221       try {
46222         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46223       }
46224       catch(std::out_of_range &_e) {
46225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46226         return 0;
46227       }
46228
46229     } catch (std::out_of_range& e) {
46230       {
46231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46232       };
46233     } catch (std::exception& e) {
46234       {
46235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46236       };
46237     } catch (Dali::DaliException e) {
46238       {
46239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46240       };
46241     } catch (...) {
46242       {
46243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46244       };
46245     }
46246   }
46247
46248   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46249   return jresult;
46250 }
46251
46252
46253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46254   void * jresult ;
46255   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46256   int arg2 ;
46257   Dali::TouchPoint *result = 0 ;
46258
46259   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46260   arg2 = (int)jarg2;
46261   {
46262     try {
46263       try {
46264         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46265       }
46266       catch(std::out_of_range &_e) {
46267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46268         return 0;
46269       }
46270
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46286       };
46287     }
46288   }
46289
46290   jresult = (void *)result;
46291   return jresult;
46292 }
46293
46294
46295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46296   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46297   int arg2 ;
46298   Dali::TouchPoint *arg3 = 0 ;
46299
46300   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46301   arg2 = (int)jarg2;
46302   arg3 = (Dali::TouchPoint *)jarg3;
46303   if (!arg3) {
46304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46305     return ;
46306   }
46307   {
46308     try {
46309       try {
46310         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46311       }
46312       catch(std::out_of_range &_e) {
46313         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46314         return ;
46315       }
46316
46317     } catch (std::out_of_range& e) {
46318       {
46319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46320       };
46321     } catch (std::exception& e) {
46322       {
46323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46324       };
46325     } catch (Dali::DaliException e) {
46326       {
46327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46328       };
46329     } catch (...) {
46330       {
46331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46332       };
46333     }
46334   }
46335
46336 }
46337
46338
46339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46340   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46341   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46342
46343   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46344   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46345   if (!arg2) {
46346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46347     return ;
46348   }
46349   {
46350     try {
46351       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46352     } catch (std::out_of_range& e) {
46353       {
46354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46355       };
46356     } catch (std::exception& e) {
46357       {
46358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46359       };
46360     } catch (Dali::DaliException e) {
46361       {
46362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46363       };
46364     } catch (...) {
46365       {
46366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46367       };
46368     }
46369   }
46370
46371 }
46372
46373
46374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46375   void * jresult ;
46376   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46377   int arg2 ;
46378   int arg3 ;
46379   std::vector< Dali::TouchPoint > *result = 0 ;
46380
46381   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46382   arg2 = (int)jarg2;
46383   arg3 = (int)jarg3;
46384   {
46385     try {
46386       try {
46387         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46388       }
46389       catch(std::out_of_range &_e) {
46390         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46391         return 0;
46392       }
46393       catch(std::invalid_argument &_e) {
46394         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46395         return 0;
46396       }
46397
46398     } catch (std::out_of_range& e) {
46399       {
46400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46401       };
46402     } catch (std::exception& e) {
46403       {
46404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (Dali::DaliException e) {
46407       {
46408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46409       };
46410     } catch (...) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46413       };
46414     }
46415   }
46416
46417   jresult = (void *)result;
46418   return jresult;
46419 }
46420
46421
46422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46423   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46424   int arg2 ;
46425   Dali::TouchPoint *arg3 = 0 ;
46426
46427   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46428   arg2 = (int)jarg2;
46429   arg3 = (Dali::TouchPoint *)jarg3;
46430   if (!arg3) {
46431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46432     return ;
46433   }
46434   {
46435     try {
46436       try {
46437         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46438       }
46439       catch(std::out_of_range &_e) {
46440         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46441         return ;
46442       }
46443
46444     } catch (std::out_of_range& e) {
46445       {
46446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46447       };
46448     } catch (std::exception& e) {
46449       {
46450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46451       };
46452     } catch (Dali::DaliException e) {
46453       {
46454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46455       };
46456     } catch (...) {
46457       {
46458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46459       };
46460     }
46461   }
46462
46463 }
46464
46465
46466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46467   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46468   int arg2 ;
46469   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46470
46471   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46472   arg2 = (int)jarg2;
46473   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46474   if (!arg3) {
46475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46476     return ;
46477   }
46478   {
46479     try {
46480       try {
46481         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46482       }
46483       catch(std::out_of_range &_e) {
46484         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46485         return ;
46486       }
46487
46488     } catch (std::out_of_range& e) {
46489       {
46490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46491       };
46492     } catch (std::exception& e) {
46493       {
46494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46495       };
46496     } catch (Dali::DaliException e) {
46497       {
46498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46499       };
46500     } catch (...) {
46501       {
46502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46503       };
46504     }
46505   }
46506
46507 }
46508
46509
46510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46511   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46512   int arg2 ;
46513
46514   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46515   arg2 = (int)jarg2;
46516   {
46517     try {
46518       try {
46519         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46520       }
46521       catch(std::out_of_range &_e) {
46522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46523         return ;
46524       }
46525
46526     } catch (std::out_of_range& e) {
46527       {
46528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46529       };
46530     } catch (std::exception& e) {
46531       {
46532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46533       };
46534     } catch (Dali::DaliException e) {
46535       {
46536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46537       };
46538     } catch (...) {
46539       {
46540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46541       };
46542     }
46543   }
46544
46545 }
46546
46547
46548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46549   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46550   int arg2 ;
46551   int arg3 ;
46552
46553   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46554   arg2 = (int)jarg2;
46555   arg3 = (int)jarg3;
46556   {
46557     try {
46558       try {
46559         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46560       }
46561       catch(std::out_of_range &_e) {
46562         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46563         return ;
46564       }
46565       catch(std::invalid_argument &_e) {
46566         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46567         return ;
46568       }
46569
46570     } catch (std::out_of_range& e) {
46571       {
46572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46573       };
46574     } catch (std::exception& e) {
46575       {
46576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46577       };
46578     } catch (Dali::DaliException e) {
46579       {
46580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46581       };
46582     } catch (...) {
46583       {
46584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46585       };
46586     }
46587   }
46588
46589 }
46590
46591
46592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46593   void * jresult ;
46594   Dali::TouchPoint *arg1 = 0 ;
46595   int arg2 ;
46596   std::vector< Dali::TouchPoint > *result = 0 ;
46597
46598   arg1 = (Dali::TouchPoint *)jarg1;
46599   if (!arg1) {
46600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46601     return 0;
46602   }
46603   arg2 = (int)jarg2;
46604   {
46605     try {
46606       try {
46607         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46608       }
46609       catch(std::out_of_range &_e) {
46610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46611         return 0;
46612       }
46613
46614     } catch (std::out_of_range& e) {
46615       {
46616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46617       };
46618     } catch (std::exception& e) {
46619       {
46620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46621       };
46622     } catch (Dali::DaliException e) {
46623       {
46624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46625       };
46626     } catch (...) {
46627       {
46628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46629       };
46630     }
46631   }
46632
46633   jresult = (void *)result;
46634   return jresult;
46635 }
46636
46637
46638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46639   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46640
46641   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46642   {
46643     try {
46644       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46645     } catch (std::out_of_range& e) {
46646       {
46647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46648       };
46649     } catch (std::exception& e) {
46650       {
46651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46652       };
46653     } catch (Dali::DaliException e) {
46654       {
46655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46656       };
46657     } catch (...) {
46658       {
46659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46660       };
46661     }
46662   }
46663
46664 }
46665
46666
46667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46668   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46669   int arg2 ;
46670   int arg3 ;
46671
46672   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46673   arg2 = (int)jarg2;
46674   arg3 = (int)jarg3;
46675   {
46676     try {
46677       try {
46678         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46679       }
46680       catch(std::out_of_range &_e) {
46681         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46682         return ;
46683       }
46684       catch(std::invalid_argument &_e) {
46685         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46686         return ;
46687       }
46688
46689     } catch (std::out_of_range& e) {
46690       {
46691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46692       };
46693     } catch (std::exception& e) {
46694       {
46695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46696       };
46697     } catch (Dali::DaliException e) {
46698       {
46699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46700       };
46701     } catch (...) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46704       };
46705     }
46706   }
46707
46708 }
46709
46710
46711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46712   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46713   int arg2 ;
46714   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46715
46716   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46717   arg2 = (int)jarg2;
46718   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46719   if (!arg3) {
46720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46721     return ;
46722   }
46723   {
46724     try {
46725       try {
46726         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46727       }
46728       catch(std::out_of_range &_e) {
46729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46730         return ;
46731       }
46732
46733     } catch (std::out_of_range& e) {
46734       {
46735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46736       };
46737     } catch (std::exception& e) {
46738       {
46739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46740       };
46741     } catch (Dali::DaliException e) {
46742       {
46743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46744       };
46745     } catch (...) {
46746       {
46747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46748       };
46749     }
46750   }
46751
46752 }
46753
46754
46755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46756   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46757
46758   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46759   {
46760     try {
46761       delete arg1;
46762     } catch (std::out_of_range& e) {
46763       {
46764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46765       };
46766     } catch (std::exception& e) {
46767       {
46768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46769       };
46770     } catch (Dali::DaliException e) {
46771       {
46772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46773       };
46774     } catch (...) {
46775       {
46776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46777       };
46778     }
46779   }
46780
46781 }
46782
46783
46784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46785   void * jresult ;
46786   Dali::Rect< int > *result = 0 ;
46787
46788   {
46789     try {
46790       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46791     } catch (std::out_of_range& e) {
46792       {
46793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46794       };
46795     } catch (std::exception& e) {
46796       {
46797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46798       };
46799     } catch (Dali::DaliException e) {
46800       {
46801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46802       };
46803     } catch (...) {
46804       {
46805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46806       };
46807     }
46808   }
46809
46810   jresult = (void *)result;
46811   return jresult;
46812 }
46813
46814
46815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46816   void * jresult ;
46817   int arg1 ;
46818   int arg2 ;
46819   int arg3 ;
46820   int arg4 ;
46821   Dali::Rect< int > *result = 0 ;
46822
46823   arg1 = (int)jarg1;
46824   arg2 = (int)jarg2;
46825   arg3 = (int)jarg3;
46826   arg4 = (int)jarg4;
46827   {
46828     try {
46829       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46830     } catch (std::out_of_range& e) {
46831       {
46832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46833       };
46834     } catch (std::exception& e) {
46835       {
46836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46837       };
46838     } catch (Dali::DaliException e) {
46839       {
46840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46841       };
46842     } catch (...) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46845       };
46846     }
46847   }
46848
46849   jresult = (void *)result;
46850   return jresult;
46851 }
46852
46853
46854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46855   void * jresult ;
46856   Dali::Rect< int > *arg1 = 0 ;
46857   Dali::Rect< int > *result = 0 ;
46858
46859   arg1 = (Dali::Rect< int > *)jarg1;
46860   if (!arg1) {
46861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46862     return 0;
46863   }
46864   {
46865     try {
46866       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46867     } catch (std::out_of_range& e) {
46868       {
46869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46870       };
46871     } catch (std::exception& e) {
46872       {
46873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46874       };
46875     } catch (Dali::DaliException e) {
46876       {
46877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46878       };
46879     } catch (...) {
46880       {
46881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46882       };
46883     }
46884   }
46885
46886   jresult = (void *)result;
46887   return jresult;
46888 }
46889
46890
46891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46892   void * jresult ;
46893   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46894   Dali::Rect< int > *arg2 = 0 ;
46895   Dali::Rect< int > *result = 0 ;
46896
46897   arg1 = (Dali::Rect< int > *)jarg1;
46898   arg2 = (Dali::Rect< int > *)jarg2;
46899   if (!arg2) {
46900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46901     return 0;
46902   }
46903   {
46904     try {
46905       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46906     } catch (std::out_of_range& e) {
46907       {
46908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46909       };
46910     } catch (std::exception& e) {
46911       {
46912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46913       };
46914     } catch (Dali::DaliException e) {
46915       {
46916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46917       };
46918     } catch (...) {
46919       {
46920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46921       };
46922     }
46923   }
46924
46925   jresult = (void *)result;
46926   return jresult;
46927 }
46928
46929
46930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46931   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46932   int arg2 ;
46933   int arg3 ;
46934   int arg4 ;
46935   int arg5 ;
46936
46937   arg1 = (Dali::Rect< int > *)jarg1;
46938   arg2 = (int)jarg2;
46939   arg3 = (int)jarg3;
46940   arg4 = (int)jarg4;
46941   arg5 = (int)jarg5;
46942   {
46943     try {
46944       (arg1)->Set(arg2,arg3,arg4,arg5);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46952       };
46953     } catch (Dali::DaliException e) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46956       };
46957     } catch (...) {
46958       {
46959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46960       };
46961     }
46962   }
46963
46964 }
46965
46966
46967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46968   unsigned int jresult ;
46969   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46970   bool result;
46971
46972   arg1 = (Dali::Rect< int > *)jarg1;
46973   {
46974     try {
46975       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46976     } catch (std::out_of_range& e) {
46977       {
46978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46979       };
46980     } catch (std::exception& e) {
46981       {
46982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (Dali::DaliException e) {
46985       {
46986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46987       };
46988     } catch (...) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46991       };
46992     }
46993   }
46994
46995   jresult = result;
46996   return jresult;
46997 }
46998
46999
47000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47001   int jresult ;
47002   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47003   int result;
47004
47005   arg1 = (Dali::Rect< int > *)jarg1;
47006   {
47007     try {
47008       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47009     } catch (std::out_of_range& e) {
47010       {
47011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (std::exception& e) {
47014       {
47015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (Dali::DaliException e) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47020       };
47021     } catch (...) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47024       };
47025     }
47026   }
47027
47028   jresult = result;
47029   return jresult;
47030 }
47031
47032
47033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47034   int jresult ;
47035   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47036   int result;
47037
47038   arg1 = (Dali::Rect< int > *)jarg1;
47039   {
47040     try {
47041       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47042     } catch (std::out_of_range& e) {
47043       {
47044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47045       };
47046     } catch (std::exception& e) {
47047       {
47048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47049       };
47050     } catch (Dali::DaliException e) {
47051       {
47052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47053       };
47054     } catch (...) {
47055       {
47056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47057       };
47058     }
47059   }
47060
47061   jresult = result;
47062   return jresult;
47063 }
47064
47065
47066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47067   int jresult ;
47068   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47069   int result;
47070
47071   arg1 = (Dali::Rect< int > *)jarg1;
47072   {
47073     try {
47074       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47075     } catch (std::out_of_range& e) {
47076       {
47077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (std::exception& e) {
47080       {
47081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47082       };
47083     } catch (Dali::DaliException e) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47086       };
47087     } catch (...) {
47088       {
47089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47090       };
47091     }
47092   }
47093
47094   jresult = result;
47095   return jresult;
47096 }
47097
47098
47099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47100   int jresult ;
47101   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47102   int result;
47103
47104   arg1 = (Dali::Rect< int > *)jarg1;
47105   {
47106     try {
47107       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47108     } catch (std::out_of_range& e) {
47109       {
47110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47111       };
47112     } catch (std::exception& e) {
47113       {
47114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47115       };
47116     } catch (Dali::DaliException e) {
47117       {
47118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47119       };
47120     } catch (...) {
47121       {
47122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47123       };
47124     }
47125   }
47126
47127   jresult = result;
47128   return jresult;
47129 }
47130
47131
47132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47133   int jresult ;
47134   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47135   int result;
47136
47137   arg1 = (Dali::Rect< int > *)jarg1;
47138   {
47139     try {
47140       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (Dali::DaliException e) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47152       };
47153     } catch (...) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47156       };
47157     }
47158   }
47159
47160   jresult = result;
47161   return jresult;
47162 }
47163
47164
47165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47166   unsigned int jresult ;
47167   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47168   Dali::Rect< int > *arg2 = 0 ;
47169   bool result;
47170
47171   arg1 = (Dali::Rect< int > *)jarg1;
47172   arg2 = (Dali::Rect< int > *)jarg2;
47173   if (!arg2) {
47174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47175     return 0;
47176   }
47177   {
47178     try {
47179       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47180     } catch (std::out_of_range& e) {
47181       {
47182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47183       };
47184     } catch (std::exception& e) {
47185       {
47186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47187       };
47188     } catch (Dali::DaliException e) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47191       };
47192     } catch (...) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47195       };
47196     }
47197   }
47198
47199   jresult = result;
47200   return jresult;
47201 }
47202
47203
47204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47205   unsigned int jresult ;
47206   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47207   Dali::Rect< int > *arg2 = 0 ;
47208   bool result;
47209
47210   arg1 = (Dali::Rect< int > *)jarg1;
47211   arg2 = (Dali::Rect< int > *)jarg2;
47212   if (!arg2) {
47213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47214     return 0;
47215   }
47216   {
47217     try {
47218       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47219     } catch (std::out_of_range& e) {
47220       {
47221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47222       };
47223     } catch (std::exception& e) {
47224       {
47225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47226       };
47227     } catch (Dali::DaliException e) {
47228       {
47229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47230       };
47231     } catch (...) {
47232       {
47233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47234       };
47235     }
47236   }
47237
47238   jresult = result;
47239   return jresult;
47240 }
47241
47242
47243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47244   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47245   int arg2 ;
47246
47247   arg1 = (Dali::Rect< int > *)jarg1;
47248   arg2 = (int)jarg2;
47249   if (arg1) (arg1)->x = arg2;
47250 }
47251
47252
47253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47254   int jresult ;
47255   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47256   int result;
47257
47258   arg1 = (Dali::Rect< int > *)jarg1;
47259   result = (int) ((arg1)->x);
47260   jresult = result;
47261   return jresult;
47262 }
47263
47264
47265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47266   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47267   int arg2 ;
47268
47269   arg1 = (Dali::Rect< int > *)jarg1;
47270   arg2 = (int)jarg2;
47271   if (arg1) (arg1)->left = arg2;
47272 }
47273
47274
47275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47276   int jresult ;
47277   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47278   int result;
47279
47280   arg1 = (Dali::Rect< int > *)jarg1;
47281   result = (int) ((arg1)->left);
47282   jresult = result;
47283   return jresult;
47284 }
47285
47286
47287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47288   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47289   int arg2 ;
47290
47291   arg1 = (Dali::Rect< int > *)jarg1;
47292   arg2 = (int)jarg2;
47293   if (arg1) (arg1)->y = arg2;
47294 }
47295
47296
47297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47298   int jresult ;
47299   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47300   int result;
47301
47302   arg1 = (Dali::Rect< int > *)jarg1;
47303   result = (int) ((arg1)->y);
47304   jresult = result;
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47310   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47311   int arg2 ;
47312
47313   arg1 = (Dali::Rect< int > *)jarg1;
47314   arg2 = (int)jarg2;
47315   if (arg1) (arg1)->right = arg2;
47316 }
47317
47318
47319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47320   int jresult ;
47321   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47322   int result;
47323
47324   arg1 = (Dali::Rect< int > *)jarg1;
47325   result = (int) ((arg1)->right);
47326   jresult = result;
47327   return jresult;
47328 }
47329
47330
47331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47332   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47333   int arg2 ;
47334
47335   arg1 = (Dali::Rect< int > *)jarg1;
47336   arg2 = (int)jarg2;
47337   if (arg1) (arg1)->width = arg2;
47338 }
47339
47340
47341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47342   int jresult ;
47343   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47344   int result;
47345
47346   arg1 = (Dali::Rect< int > *)jarg1;
47347   result = (int) ((arg1)->width);
47348   jresult = result;
47349   return jresult;
47350 }
47351
47352
47353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47354   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47355   int arg2 ;
47356
47357   arg1 = (Dali::Rect< int > *)jarg1;
47358   arg2 = (int)jarg2;
47359   if (arg1) (arg1)->bottom = arg2;
47360 }
47361
47362
47363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47364   int jresult ;
47365   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47366   int result;
47367
47368   arg1 = (Dali::Rect< int > *)jarg1;
47369   result = (int) ((arg1)->bottom);
47370   jresult = result;
47371   return jresult;
47372 }
47373
47374
47375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47376   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47377   int arg2 ;
47378
47379   arg1 = (Dali::Rect< int > *)jarg1;
47380   arg2 = (int)jarg2;
47381   if (arg1) (arg1)->height = arg2;
47382 }
47383
47384
47385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47386   int jresult ;
47387   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47388   int result;
47389
47390   arg1 = (Dali::Rect< int > *)jarg1;
47391   result = (int) ((arg1)->height);
47392   jresult = result;
47393   return jresult;
47394 }
47395
47396
47397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47398   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47399   int arg2 ;
47400
47401   arg1 = (Dali::Rect< int > *)jarg1;
47402   arg2 = (int)jarg2;
47403   if (arg1) (arg1)->top = arg2;
47404 }
47405
47406
47407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47408   int jresult ;
47409   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47410   int result;
47411
47412   arg1 = (Dali::Rect< int > *)jarg1;
47413   result = (int) ((arg1)->top);
47414   jresult = result;
47415   return jresult;
47416 }
47417
47418
47419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47420   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47421
47422   arg1 = (Dali::Rect< int > *)jarg1;
47423   {
47424     try {
47425       delete arg1;
47426     } catch (std::out_of_range& e) {
47427       {
47428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47429       };
47430     } catch (std::exception& e) {
47431       {
47432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47433       };
47434     } catch (Dali::DaliException e) {
47435       {
47436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47437       };
47438     } catch (...) {
47439       {
47440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47441       };
47442     }
47443   }
47444
47445 }
47446
47447
47448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47449   void * jresult ;
47450   Dali::Rect< float > *result = 0 ;
47451
47452   {
47453     try {
47454       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47455     } catch (std::out_of_range& e) {
47456       {
47457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47458       };
47459     } catch (std::exception& e) {
47460       {
47461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47462       };
47463     } catch (Dali::DaliException e) {
47464       {
47465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47466       };
47467     } catch (...) {
47468       {
47469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47470       };
47471     }
47472   }
47473
47474   jresult = (void *)result;
47475   return jresult;
47476 }
47477
47478
47479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47480   void * jresult ;
47481   float arg1 ;
47482   float arg2 ;
47483   float arg3 ;
47484   float arg4 ;
47485   Dali::Rect< float > *result = 0 ;
47486
47487   arg1 = (float)jarg1;
47488   arg2 = (float)jarg2;
47489   arg3 = (float)jarg4;
47490   arg4 = (float)jarg3;
47491   {
47492     try {
47493       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
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_new_PaddingType__SWIG_2(void * jarg1) {
47519   void * jresult ;
47520   Dali::Rect< float > *arg1 = 0 ;
47521   Dali::Rect< float > *result = 0 ;
47522
47523   arg1 = (Dali::Rect< float > *)jarg1;
47524   if (!arg1) {
47525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47526     return 0;
47527   }
47528   {
47529     try {
47530       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47531     } catch (std::out_of_range& e) {
47532       {
47533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47534       };
47535     } catch (std::exception& e) {
47536       {
47537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47538       };
47539     } catch (Dali::DaliException e) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47542       };
47543     } catch (...) {
47544       {
47545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47546       };
47547     }
47548   }
47549
47550   jresult = (void *)result;
47551   return jresult;
47552 }
47553
47554
47555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47556   void * jresult ;
47557   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47558   Dali::Rect< float > *arg2 = 0 ;
47559   Dali::Rect< float > *result = 0 ;
47560
47561   arg1 = (Dali::Rect< float > *)jarg1;
47562   arg2 = (Dali::Rect< float > *)jarg2;
47563   if (!arg2) {
47564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47565     return 0;
47566   }
47567   {
47568     try {
47569       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47570     } catch (std::out_of_range& e) {
47571       {
47572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47573       };
47574     } catch (std::exception& e) {
47575       {
47576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47577       };
47578     } catch (Dali::DaliException e) {
47579       {
47580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47581       };
47582     } catch (...) {
47583       {
47584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47585       };
47586     }
47587   }
47588
47589   jresult = (void *)result;
47590   return jresult;
47591 }
47592
47593
47594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47595   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47596   float arg2 ;
47597   float arg3 ;
47598   float arg4 ;
47599   float arg5 ;
47600
47601   arg1 = (Dali::Rect< float > *)jarg1;
47602   arg2 = (float)jarg2;
47603   arg3 = (float)jarg3;
47604   arg4 = (float)jarg5;
47605   arg5 = (float)jarg4;
47606   {
47607     try {
47608       (arg1)->Set(arg2,arg3,arg4,arg5);
47609     } catch (std::out_of_range& e) {
47610       {
47611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47612       };
47613     } catch (std::exception& e) {
47614       {
47615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47616       };
47617     } catch (Dali::DaliException e) {
47618       {
47619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47620       };
47621     } catch (...) {
47622       {
47623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47624       };
47625     }
47626   }
47627
47628 }
47629
47630
47631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47632   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47633   float arg2 ;
47634
47635   arg1 = (Dali::Rect< float > *)jarg1;
47636   arg2 = (float)jarg2;
47637   if (arg1) (arg1)->left = arg2;
47638 }
47639
47640
47641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47642   float jresult ;
47643   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47644   float result;
47645
47646   arg1 = (Dali::Rect< float > *)jarg1;
47647   result = (float) ((arg1)->left);
47648   jresult = result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47654   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47655   float arg2 ;
47656
47657   arg1 = (Dali::Rect< float > *)jarg1;
47658   arg2 = (float)jarg2;
47659   if (arg1) (arg1)->left = arg2;
47660 }
47661
47662
47663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47664   float jresult ;
47665   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47666   float result;
47667
47668   arg1 = (Dali::Rect< float > *)jarg1;
47669   result = (float) ((arg1)->left);
47670   jresult = result;
47671   return jresult;
47672 }
47673
47674
47675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47676   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47677   float arg2 ;
47678
47679   arg1 = (Dali::Rect< float > *)jarg1;
47680   arg2 = (float)jarg2;
47681   if (arg1) (arg1)->right = arg2;
47682 }
47683
47684
47685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47686   float jresult ;
47687   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47688   float result;
47689
47690   arg1 = (Dali::Rect< float > *)jarg1;
47691   result = (float) ((arg1)->right);
47692   jresult = result;
47693   return jresult;
47694 }
47695
47696
47697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47698   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47699   float arg2 ;
47700
47701   arg1 = (Dali::Rect< float > *)jarg1;
47702   arg2 = (float)jarg2;
47703   if (arg1) (arg1)->right = arg2;
47704 }
47705
47706
47707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47708   float jresult ;
47709   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47710   float result;
47711
47712   arg1 = (Dali::Rect< float > *)jarg1;
47713   result = (float) ((arg1)->right);
47714   jresult = result;
47715   return jresult;
47716 }
47717
47718
47719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47720   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47721   float arg2 ;
47722
47723   arg1 = (Dali::Rect< float > *)jarg1;
47724   arg2 = (float)jarg2;
47725   if (arg1) (arg1)->bottom = arg2;
47726 }
47727
47728
47729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47730   float jresult ;
47731   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47732   float result;
47733
47734   arg1 = (Dali::Rect< float > *)jarg1;
47735   result = (float) ((arg1)->bottom);
47736   jresult = result;
47737   return jresult;
47738 }
47739
47740
47741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47742   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47743   float arg2 ;
47744
47745   arg1 = (Dali::Rect< float > *)jarg1;
47746   arg2 = (float)jarg2;
47747   if (arg1) (arg1)->top = arg2;
47748 }
47749
47750
47751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47752   float jresult ;
47753   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47754   float result;
47755
47756   arg1 = (Dali::Rect< float > *)jarg1;
47757   result = (float) ((arg1)->top);
47758   jresult = result;
47759   return jresult;
47760 }
47761
47762
47763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47764   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47765
47766   arg1 = (Dali::Rect< float > *)jarg1;
47767   {
47768     try {
47769       delete arg1;
47770     } catch (std::out_of_range& e) {
47771       {
47772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47773       };
47774     } catch (std::exception& e) {
47775       {
47776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47777       };
47778     } catch (Dali::DaliException e) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47781       };
47782     } catch (...) {
47783       {
47784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47785       };
47786     }
47787   }
47788
47789 }
47790
47791
47792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47793   int jresult ;
47794   int result;
47795
47796   result = (int)Dali::Vector< int >::BaseType;
47797   jresult = (int)result;
47798   return jresult;
47799 }
47800
47801
47802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47803   void * jresult ;
47804   Dali::Vector< int > *result = 0 ;
47805
47806   {
47807     try {
47808       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47809     } catch (std::out_of_range& e) {
47810       {
47811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47812       };
47813     } catch (std::exception& e) {
47814       {
47815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47816       };
47817     } catch (Dali::DaliException e) {
47818       {
47819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47824       };
47825     }
47826   }
47827
47828   jresult = (void *)result;
47829   return jresult;
47830 }
47831
47832
47833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47834   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47835
47836   arg1 = (Dali::Vector< int > *)jarg1;
47837   {
47838     try {
47839       delete arg1;
47840     } catch (std::out_of_range& e) {
47841       {
47842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47843       };
47844     } catch (std::exception& e) {
47845       {
47846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47847       };
47848     } catch (Dali::DaliException e) {
47849       {
47850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47851       };
47852     } catch (...) {
47853       {
47854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47855       };
47856     }
47857   }
47858
47859 }
47860
47861
47862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47863   void * jresult ;
47864   Dali::Vector< int > *arg1 = 0 ;
47865   Dali::Vector< int > *result = 0 ;
47866
47867   arg1 = (Dali::Vector< int > *)jarg1;
47868   if (!arg1) {
47869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47870     return 0;
47871   }
47872   {
47873     try {
47874       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47875     } catch (std::out_of_range& e) {
47876       {
47877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47878       };
47879     } catch (std::exception& e) {
47880       {
47881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47882       };
47883     } catch (Dali::DaliException e) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47886       };
47887     } catch (...) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47890       };
47891     }
47892   }
47893
47894   jresult = (void *)result;
47895   return jresult;
47896 }
47897
47898
47899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47900   void * jresult ;
47901   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47902   Dali::Vector< int > *arg2 = 0 ;
47903   Dali::Vector< int > *result = 0 ;
47904
47905   arg1 = (Dali::Vector< int > *)jarg1;
47906   arg2 = (Dali::Vector< int > *)jarg2;
47907   if (!arg2) {
47908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47909     return 0;
47910   }
47911   {
47912     try {
47913       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47914     } catch (std::out_of_range& e) {
47915       {
47916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47917       };
47918     } catch (std::exception& e) {
47919       {
47920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47921       };
47922     } catch (Dali::DaliException e) {
47923       {
47924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47925       };
47926     } catch (...) {
47927       {
47928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47929       };
47930     }
47931   }
47932
47933   jresult = (void *)result;
47934   return jresult;
47935 }
47936
47937
47938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47939   void * jresult ;
47940   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47941   Dali::Vector< int >::Iterator result;
47942
47943   arg1 = (Dali::Vector< int > *)jarg1;
47944   {
47945     try {
47946       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47947     } catch (std::out_of_range& e) {
47948       {
47949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47950       };
47951     } catch (std::exception& e) {
47952       {
47953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47954       };
47955     } catch (Dali::DaliException e) {
47956       {
47957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47958       };
47959     } catch (...) {
47960       {
47961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47962       };
47963     }
47964   }
47965
47966   jresult = (void *)result;
47967   return jresult;
47968 }
47969
47970
47971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47972   void * jresult ;
47973   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47974   Dali::Vector< int >::Iterator result;
47975
47976   arg1 = (Dali::Vector< int > *)jarg1;
47977   {
47978     try {
47979       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47980     } catch (std::out_of_range& e) {
47981       {
47982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47983       };
47984     } catch (std::exception& e) {
47985       {
47986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47987       };
47988     } catch (Dali::DaliException e) {
47989       {
47990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47991       };
47992     } catch (...) {
47993       {
47994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47995       };
47996     }
47997   }
47998
47999   jresult = (void *)result;
48000   return jresult;
48001 }
48002
48003
48004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48005   void * jresult ;
48006   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48007   Dali::Vector< int >::SizeType arg2 ;
48008   Dali::Vector< int >::ItemType *result = 0 ;
48009
48010   arg1 = (Dali::Vector< int > *)jarg1;
48011   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48012   {
48013     try {
48014       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48015     } catch (std::out_of_range& e) {
48016       {
48017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48018       };
48019     } catch (std::exception& e) {
48020       {
48021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48022       };
48023     } catch (Dali::DaliException e) {
48024       {
48025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48030       };
48031     }
48032   }
48033
48034   jresult = (void *)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48040   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48041   Dali::Vector< int >::ItemType *arg2 = 0 ;
48042   Dali::Vector< int >::ItemType temp2 ;
48043
48044   arg1 = (Dali::Vector< int > *)jarg1;
48045   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48046   arg2 = &temp2;
48047   {
48048     try {
48049       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48050     } catch (std::out_of_range& e) {
48051       {
48052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48053       };
48054     } catch (std::exception& e) {
48055       {
48056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48057       };
48058     } catch (Dali::DaliException e) {
48059       {
48060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48061       };
48062     } catch (...) {
48063       {
48064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48065       };
48066     }
48067   }
48068
48069 }
48070
48071
48072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48073   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48074   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48075   Dali::Vector< int >::ItemType *arg3 = 0 ;
48076   Dali::Vector< int >::ItemType temp3 ;
48077
48078   arg1 = (Dali::Vector< int > *)jarg1;
48079   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48080   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48081   arg3 = &temp3;
48082   {
48083     try {
48084       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48085     } catch (std::out_of_range& e) {
48086       {
48087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48088       };
48089     } catch (std::exception& e) {
48090       {
48091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48092       };
48093     } catch (Dali::DaliException e) {
48094       {
48095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48096       };
48097     } catch (...) {
48098       {
48099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48100       };
48101     }
48102   }
48103
48104 }
48105
48106
48107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48108   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48109   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48110   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48111   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48112
48113   arg1 = (Dali::Vector< int > *)jarg1;
48114   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48115   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48116   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48117   {
48118     try {
48119       (arg1)->Insert(arg2,arg3,arg4);
48120     } catch (std::out_of_range& e) {
48121       {
48122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (std::exception& e) {
48125       {
48126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48127       };
48128     } catch (Dali::DaliException e) {
48129       {
48130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48131       };
48132     } catch (...) {
48133       {
48134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48135       };
48136     }
48137   }
48138
48139 }
48140
48141
48142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48143   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48144   Dali::Vector< int >::SizeType arg2 ;
48145
48146   arg1 = (Dali::Vector< int > *)jarg1;
48147   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48148   {
48149     try {
48150       (arg1)->Reserve(arg2);
48151     } catch (std::out_of_range& e) {
48152       {
48153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48154       };
48155     } catch (std::exception& e) {
48156       {
48157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48158       };
48159     } catch (Dali::DaliException e) {
48160       {
48161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48162       };
48163     } catch (...) {
48164       {
48165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48166       };
48167     }
48168   }
48169
48170 }
48171
48172
48173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48174   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48175   Dali::Vector< int >::SizeType arg2 ;
48176
48177   arg1 = (Dali::Vector< int > *)jarg1;
48178   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48179   {
48180     try {
48181       (arg1)->Resize(arg2);
48182     } catch (std::out_of_range& e) {
48183       {
48184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48185       };
48186     } catch (std::exception& e) {
48187       {
48188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48189       };
48190     } catch (Dali::DaliException e) {
48191       {
48192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48193       };
48194     } catch (...) {
48195       {
48196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48197       };
48198     }
48199   }
48200
48201 }
48202
48203
48204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48205   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48206   Dali::Vector< int >::SizeType arg2 ;
48207   Dali::Vector< int >::ItemType *arg3 = 0 ;
48208   Dali::Vector< int >::ItemType temp3 ;
48209
48210   arg1 = (Dali::Vector< int > *)jarg1;
48211   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48212   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48213   arg3 = &temp3;
48214   {
48215     try {
48216       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48217     } catch (std::out_of_range& e) {
48218       {
48219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48220       };
48221     } catch (std::exception& e) {
48222       {
48223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48224       };
48225     } catch (Dali::DaliException e) {
48226       {
48227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48228       };
48229     } catch (...) {
48230       {
48231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48232       };
48233     }
48234   }
48235
48236 }
48237
48238
48239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48240   void * jresult ;
48241   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48242   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48243   Dali::Vector< int >::Iterator result;
48244
48245   arg1 = (Dali::Vector< int > *)jarg1;
48246   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48247   {
48248     try {
48249       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48250     } catch (std::out_of_range& e) {
48251       {
48252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48253       };
48254     } catch (std::exception& e) {
48255       {
48256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48257       };
48258     } catch (Dali::DaliException e) {
48259       {
48260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48261       };
48262     } catch (...) {
48263       {
48264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48265       };
48266     }
48267   }
48268
48269   jresult = (void *)result;
48270   return jresult;
48271 }
48272
48273
48274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48275   void * jresult ;
48276   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48277   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48278   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48279   Dali::Vector< int >::Iterator result;
48280
48281   arg1 = (Dali::Vector< int > *)jarg1;
48282   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48283   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48284   {
48285     try {
48286       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48287     } catch (std::out_of_range& e) {
48288       {
48289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48290       };
48291     } catch (std::exception& e) {
48292       {
48293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48294       };
48295     } catch (Dali::DaliException e) {
48296       {
48297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48298       };
48299     } catch (...) {
48300       {
48301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48302       };
48303     }
48304   }
48305
48306   jresult = (void *)result;
48307   return jresult;
48308 }
48309
48310
48311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48312   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48313   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48314
48315   arg1 = (Dali::Vector< int > *)jarg1;
48316   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48317   {
48318     try {
48319       (arg1)->Remove(arg2);
48320     } catch (std::out_of_range& e) {
48321       {
48322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48323       };
48324     } catch (std::exception& e) {
48325       {
48326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48327       };
48328     } catch (Dali::DaliException e) {
48329       {
48330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48331       };
48332     } catch (...) {
48333       {
48334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48335       };
48336     }
48337   }
48338
48339 }
48340
48341
48342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48343   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48344   Dali::Vector< int > *arg2 = 0 ;
48345
48346   arg1 = (Dali::Vector< int > *)jarg1;
48347   arg2 = (Dali::Vector< int > *)jarg2;
48348   if (!arg2) {
48349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48350     return ;
48351   }
48352   {
48353     try {
48354       (arg1)->Swap(*arg2);
48355     } catch (std::out_of_range& e) {
48356       {
48357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48358       };
48359     } catch (std::exception& e) {
48360       {
48361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48362       };
48363     } catch (Dali::DaliException e) {
48364       {
48365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48366       };
48367     } catch (...) {
48368       {
48369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48370       };
48371     }
48372   }
48373
48374 }
48375
48376
48377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48378   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48379
48380   arg1 = (Dali::Vector< int > *)jarg1;
48381   {
48382     try {
48383       (arg1)->Clear();
48384     } catch (std::out_of_range& e) {
48385       {
48386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48387       };
48388     } catch (std::exception& e) {
48389       {
48390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48391       };
48392     } catch (Dali::DaliException e) {
48393       {
48394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48395       };
48396     } catch (...) {
48397       {
48398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48399       };
48400     }
48401   }
48402
48403 }
48404
48405
48406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48407   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48408
48409   arg1 = (Dali::Vector< int > *)jarg1;
48410   {
48411     try {
48412       (arg1)->Release();
48413     } catch (std::out_of_range& e) {
48414       {
48415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48416       };
48417     } catch (std::exception& e) {
48418       {
48419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48420       };
48421     } catch (Dali::DaliException e) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48424       };
48425     } catch (...) {
48426       {
48427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48428       };
48429     }
48430   }
48431
48432 }
48433
48434
48435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48436   int jresult ;
48437   int result;
48438
48439   result = (int)Dali::Vector< float >::BaseType;
48440   jresult = (int)result;
48441   return jresult;
48442 }
48443
48444
48445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48446   void * jresult ;
48447   Dali::Vector< float > *result = 0 ;
48448
48449   {
48450     try {
48451       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48452     } catch (std::out_of_range& e) {
48453       {
48454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48455       };
48456     } catch (std::exception& e) {
48457       {
48458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48459       };
48460     } catch (Dali::DaliException e) {
48461       {
48462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48463       };
48464     } catch (...) {
48465       {
48466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48467       };
48468     }
48469   }
48470
48471   jresult = (void *)result;
48472   return jresult;
48473 }
48474
48475
48476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48477   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48478
48479   arg1 = (Dali::Vector< float > *)jarg1;
48480   {
48481     try {
48482       delete arg1;
48483     } catch (std::out_of_range& e) {
48484       {
48485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48486       };
48487     } catch (std::exception& e) {
48488       {
48489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48490       };
48491     } catch (Dali::DaliException e) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48494       };
48495     } catch (...) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48498       };
48499     }
48500   }
48501
48502 }
48503
48504
48505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48506   void * jresult ;
48507   Dali::Vector< float > *arg1 = 0 ;
48508   Dali::Vector< float > *result = 0 ;
48509
48510   arg1 = (Dali::Vector< float > *)jarg1;
48511   if (!arg1) {
48512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48513     return 0;
48514   }
48515   {
48516     try {
48517       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48518     } catch (std::out_of_range& e) {
48519       {
48520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48521       };
48522     } catch (std::exception& e) {
48523       {
48524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48525       };
48526     } catch (Dali::DaliException e) {
48527       {
48528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48533       };
48534     }
48535   }
48536
48537   jresult = (void *)result;
48538   return jresult;
48539 }
48540
48541
48542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48543   void * jresult ;
48544   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48545   Dali::Vector< float > *arg2 = 0 ;
48546   Dali::Vector< float > *result = 0 ;
48547
48548   arg1 = (Dali::Vector< float > *)jarg1;
48549   arg2 = (Dali::Vector< float > *)jarg2;
48550   if (!arg2) {
48551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48552     return 0;
48553   }
48554   {
48555     try {
48556       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48557     } catch (std::out_of_range& e) {
48558       {
48559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48560       };
48561     } catch (std::exception& e) {
48562       {
48563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48564       };
48565     } catch (Dali::DaliException e) {
48566       {
48567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48568       };
48569     } catch (...) {
48570       {
48571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48572       };
48573     }
48574   }
48575
48576   jresult = (void *)result;
48577   return jresult;
48578 }
48579
48580
48581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48582   void * jresult ;
48583   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48584   Dali::Vector< float >::Iterator result;
48585
48586   arg1 = (Dali::Vector< float > *)jarg1;
48587   {
48588     try {
48589       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48590     } catch (std::out_of_range& e) {
48591       {
48592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48593       };
48594     } catch (std::exception& e) {
48595       {
48596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48597       };
48598     } catch (Dali::DaliException e) {
48599       {
48600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48601       };
48602     } catch (...) {
48603       {
48604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48605       };
48606     }
48607   }
48608
48609   jresult = (void *)result;
48610   return jresult;
48611 }
48612
48613
48614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48615   void * jresult ;
48616   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48617   Dali::Vector< float >::Iterator result;
48618
48619   arg1 = (Dali::Vector< float > *)jarg1;
48620   {
48621     try {
48622       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48623     } catch (std::out_of_range& e) {
48624       {
48625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48626       };
48627     } catch (std::exception& e) {
48628       {
48629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48630       };
48631     } catch (Dali::DaliException e) {
48632       {
48633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48634       };
48635     } catch (...) {
48636       {
48637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48638       };
48639     }
48640   }
48641
48642   jresult = (void *)result;
48643   return jresult;
48644 }
48645
48646
48647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48648   void * jresult ;
48649   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48650   Dali::Vector< float >::SizeType arg2 ;
48651   Dali::Vector< float >::ItemType *result = 0 ;
48652
48653   arg1 = (Dali::Vector< float > *)jarg1;
48654   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48655   {
48656     try {
48657       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48658     } catch (std::out_of_range& e) {
48659       {
48660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48661       };
48662     } catch (std::exception& e) {
48663       {
48664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48665       };
48666     } catch (Dali::DaliException e) {
48667       {
48668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48669       };
48670     } catch (...) {
48671       {
48672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48673       };
48674     }
48675   }
48676
48677   jresult = (void *)result;
48678   return jresult;
48679 }
48680
48681
48682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48683   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48684   Dali::Vector< float >::ItemType *arg2 = 0 ;
48685   Dali::Vector< float >::ItemType temp2 ;
48686
48687   arg1 = (Dali::Vector< float > *)jarg1;
48688   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48689   arg2 = &temp2;
48690   {
48691     try {
48692       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48693     } catch (std::out_of_range& e) {
48694       {
48695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48696       };
48697     } catch (std::exception& e) {
48698       {
48699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48700       };
48701     } catch (Dali::DaliException e) {
48702       {
48703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48704       };
48705     } catch (...) {
48706       {
48707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48708       };
48709     }
48710   }
48711
48712 }
48713
48714
48715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48716   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48717   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48718   Dali::Vector< float >::ItemType *arg3 = 0 ;
48719   Dali::Vector< float >::ItemType temp3 ;
48720
48721   arg1 = (Dali::Vector< float > *)jarg1;
48722   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48723   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48724   arg3 = &temp3;
48725   {
48726     try {
48727       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48728     } catch (std::out_of_range& e) {
48729       {
48730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48731       };
48732     } catch (std::exception& e) {
48733       {
48734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48735       };
48736     } catch (Dali::DaliException e) {
48737       {
48738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48739       };
48740     } catch (...) {
48741       {
48742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48743       };
48744     }
48745   }
48746
48747 }
48748
48749
48750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48751   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48752   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48753   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48754   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48755
48756   arg1 = (Dali::Vector< float > *)jarg1;
48757   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48758   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48759   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48760   {
48761     try {
48762       (arg1)->Insert(arg2,arg3,arg4);
48763     } catch (std::out_of_range& e) {
48764       {
48765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48766       };
48767     } catch (std::exception& e) {
48768       {
48769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48770       };
48771     } catch (Dali::DaliException e) {
48772       {
48773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48774       };
48775     } catch (...) {
48776       {
48777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48778       };
48779     }
48780   }
48781
48782 }
48783
48784
48785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48786   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48787   Dali::Vector< float >::SizeType arg2 ;
48788
48789   arg1 = (Dali::Vector< float > *)jarg1;
48790   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48791   {
48792     try {
48793       (arg1)->Reserve(arg2);
48794     } catch (std::out_of_range& e) {
48795       {
48796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48797       };
48798     } catch (std::exception& e) {
48799       {
48800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48801       };
48802     } catch (Dali::DaliException e) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48805       };
48806     } catch (...) {
48807       {
48808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48809       };
48810     }
48811   }
48812
48813 }
48814
48815 //// ========================= end of part 2 =============================
48816
48817 //// ========================== start part 3 ===============================
48818
48819
48820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48821   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48822   Dali::Vector< float >::SizeType arg2 ;
48823
48824   arg1 = (Dali::Vector< float > *)jarg1;
48825   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48826   {
48827     try {
48828       (arg1)->Resize(arg2);
48829     } catch (std::out_of_range& e) {
48830       {
48831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48832       };
48833     } catch (std::exception& e) {
48834       {
48835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (Dali::DaliException e) {
48838       {
48839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48840       };
48841     } catch (...) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48844       };
48845     }
48846   }
48847
48848 }
48849
48850
48851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48852   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48853   Dali::Vector< float >::SizeType arg2 ;
48854   Dali::Vector< float >::ItemType *arg3 = 0 ;
48855   Dali::Vector< float >::ItemType temp3 ;
48856
48857   arg1 = (Dali::Vector< float > *)jarg1;
48858   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48859   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48860   arg3 = &temp3;
48861   {
48862     try {
48863       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48864     } catch (std::out_of_range& e) {
48865       {
48866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48867       };
48868     } catch (std::exception& e) {
48869       {
48870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48871       };
48872     } catch (Dali::DaliException e) {
48873       {
48874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48875       };
48876     } catch (...) {
48877       {
48878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48879       };
48880     }
48881   }
48882
48883 }
48884
48885
48886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48887   void * jresult ;
48888   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48889   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48890   Dali::Vector< float >::Iterator result;
48891
48892   arg1 = (Dali::Vector< float > *)jarg1;
48893   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48894   {
48895     try {
48896       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48897     } catch (std::out_of_range& e) {
48898       {
48899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48900       };
48901     } catch (std::exception& e) {
48902       {
48903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48904       };
48905     } catch (Dali::DaliException e) {
48906       {
48907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48908       };
48909     } catch (...) {
48910       {
48911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48912       };
48913     }
48914   }
48915
48916   jresult = (void *)result;
48917   return jresult;
48918 }
48919
48920
48921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48922   void * jresult ;
48923   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48924   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48925   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48926   Dali::Vector< float >::Iterator result;
48927
48928   arg1 = (Dali::Vector< float > *)jarg1;
48929   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48930   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48931   {
48932     try {
48933       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48934     } catch (std::out_of_range& e) {
48935       {
48936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48937       };
48938     } catch (std::exception& e) {
48939       {
48940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48941       };
48942     } catch (Dali::DaliException e) {
48943       {
48944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48945       };
48946     } catch (...) {
48947       {
48948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48949       };
48950     }
48951   }
48952
48953   jresult = (void *)result;
48954   return jresult;
48955 }
48956
48957
48958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48959   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48960   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48961
48962   arg1 = (Dali::Vector< float > *)jarg1;
48963   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48964   {
48965     try {
48966       (arg1)->Remove(arg2);
48967     } catch (std::out_of_range& e) {
48968       {
48969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48970       };
48971     } catch (std::exception& e) {
48972       {
48973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48974       };
48975     } catch (Dali::DaliException e) {
48976       {
48977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48978       };
48979     } catch (...) {
48980       {
48981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48982       };
48983     }
48984   }
48985
48986 }
48987
48988
48989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48990   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48991   Dali::Vector< float > *arg2 = 0 ;
48992
48993   arg1 = (Dali::Vector< float > *)jarg1;
48994   arg2 = (Dali::Vector< float > *)jarg2;
48995   if (!arg2) {
48996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48997     return ;
48998   }
48999   {
49000     try {
49001       (arg1)->Swap(*arg2);
49002     } catch (std::out_of_range& e) {
49003       {
49004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49005       };
49006     } catch (std::exception& e) {
49007       {
49008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49009       };
49010     } catch (Dali::DaliException e) {
49011       {
49012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49013       };
49014     } catch (...) {
49015       {
49016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49017       };
49018     }
49019   }
49020
49021 }
49022
49023
49024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49025   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49026
49027   arg1 = (Dali::Vector< float > *)jarg1;
49028   {
49029     try {
49030       (arg1)->Clear();
49031     } catch (std::out_of_range& e) {
49032       {
49033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49034       };
49035     } catch (std::exception& e) {
49036       {
49037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49038       };
49039     } catch (Dali::DaliException e) {
49040       {
49041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49042       };
49043     } catch (...) {
49044       {
49045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49046       };
49047     }
49048   }
49049
49050 }
49051
49052
49053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49054   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49055
49056   arg1 = (Dali::Vector< float > *)jarg1;
49057   {
49058     try {
49059       (arg1)->Release();
49060     } catch (std::out_of_range& e) {
49061       {
49062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49063       };
49064     } catch (std::exception& e) {
49065       {
49066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49067       };
49068     } catch (Dali::DaliException e) {
49069       {
49070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49071       };
49072     } catch (...) {
49073       {
49074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49075       };
49076     }
49077   }
49078
49079 }
49080
49081
49082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49083   int jresult ;
49084   int result;
49085
49086   result = (int)Dali::Vector< unsigned char >::BaseType;
49087   jresult = (int)result;
49088   return jresult;
49089 }
49090
49091
49092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49093   void * jresult ;
49094   Dali::Vector< unsigned char > *result = 0 ;
49095
49096   {
49097     try {
49098       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49099     } catch (std::out_of_range& e) {
49100       {
49101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49102       };
49103     } catch (std::exception& e) {
49104       {
49105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49106       };
49107     } catch (Dali::DaliException e) {
49108       {
49109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49110       };
49111     } catch (...) {
49112       {
49113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49114       };
49115     }
49116   }
49117
49118   jresult = (void *)result;
49119   return jresult;
49120 }
49121
49122
49123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49124   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49125
49126   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49127   {
49128     try {
49129       delete arg1;
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49137       };
49138     } catch (Dali::DaliException e) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49141       };
49142     } catch (...) {
49143       {
49144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49145       };
49146     }
49147   }
49148
49149 }
49150
49151
49152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49153   void * jresult ;
49154   Dali::Vector< unsigned char > *arg1 = 0 ;
49155   Dali::Vector< unsigned char > *result = 0 ;
49156
49157   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49158   if (!arg1) {
49159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49160     return 0;
49161   }
49162   {
49163     try {
49164       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49165     } catch (std::out_of_range& e) {
49166       {
49167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49168       };
49169     } catch (std::exception& e) {
49170       {
49171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49172       };
49173     } catch (Dali::DaliException e) {
49174       {
49175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49180       };
49181     }
49182   }
49183
49184   jresult = (void *)result;
49185   return jresult;
49186 }
49187
49188
49189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49190   void * jresult ;
49191   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49192   Dali::Vector< unsigned char > *arg2 = 0 ;
49193   Dali::Vector< unsigned char > *result = 0 ;
49194
49195   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49196   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49197   if (!arg2) {
49198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49199     return 0;
49200   }
49201   {
49202     try {
49203       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49204     } catch (std::out_of_range& e) {
49205       {
49206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49207       };
49208     } catch (std::exception& e) {
49209       {
49210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49211       };
49212     } catch (Dali::DaliException e) {
49213       {
49214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49215       };
49216     } catch (...) {
49217       {
49218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49219       };
49220     }
49221   }
49222
49223   jresult = (void *)result;
49224   return jresult;
49225 }
49226
49227
49228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49229   void * jresult ;
49230   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49231   Dali::Vector< unsigned char >::Iterator result;
49232
49233   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49234   {
49235     try {
49236       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49237     } catch (std::out_of_range& e) {
49238       {
49239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49240       };
49241     } catch (std::exception& e) {
49242       {
49243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (Dali::DaliException e) {
49246       {
49247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49248       };
49249     } catch (...) {
49250       {
49251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49252       };
49253     }
49254   }
49255
49256   jresult = (void *)result;
49257   return jresult;
49258 }
49259
49260
49261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49262   void * jresult ;
49263   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49264   Dali::Vector< unsigned char >::Iterator result;
49265
49266   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49267   {
49268     try {
49269       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49270     } catch (std::out_of_range& e) {
49271       {
49272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49273       };
49274     } catch (std::exception& e) {
49275       {
49276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (Dali::DaliException e) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49281       };
49282     } catch (...) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49285       };
49286     }
49287   }
49288
49289   jresult = (void *)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49295   void * jresult ;
49296   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49297   Dali::Vector< unsigned char >::SizeType arg2 ;
49298   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49299
49300   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49301   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49302   {
49303     try {
49304       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49305     } catch (std::out_of_range& e) {
49306       {
49307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49308       };
49309     } catch (std::exception& e) {
49310       {
49311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49312       };
49313     } catch (Dali::DaliException e) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49316       };
49317     } catch (...) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49320       };
49321     }
49322   }
49323
49324   jresult = (void *)result;
49325   return jresult;
49326 }
49327
49328
49329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49330   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49331   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49332   Dali::Vector< unsigned char >::ItemType temp2 ;
49333
49334   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49335   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49336   arg2 = &temp2;
49337   {
49338     try {
49339       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49340     } catch (std::out_of_range& e) {
49341       {
49342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49343       };
49344     } catch (std::exception& e) {
49345       {
49346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49347       };
49348     } catch (Dali::DaliException e) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49351       };
49352     } catch (...) {
49353       {
49354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49355       };
49356     }
49357   }
49358
49359 }
49360
49361
49362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49363   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49364   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49365   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49366   Dali::Vector< unsigned char >::ItemType temp3 ;
49367
49368   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49369   arg2 = jarg2;
49370   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49371   arg3 = &temp3;
49372   {
49373     try {
49374       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49375     } catch (std::out_of_range& e) {
49376       {
49377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (std::exception& e) {
49380       {
49381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49382       };
49383     } catch (Dali::DaliException e) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49386       };
49387     } catch (...) {
49388       {
49389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49390       };
49391     }
49392   }
49393
49394
49395
49396 }
49397
49398
49399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49400   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49401   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49402   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49403   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49404
49405   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49406   arg2 = jarg2;
49407   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49408   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49409   {
49410     try {
49411       (arg1)->Insert(arg2,arg3,arg4);
49412     } catch (std::out_of_range& e) {
49413       {
49414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49415       };
49416     } catch (std::exception& e) {
49417       {
49418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49419       };
49420     } catch (Dali::DaliException e) {
49421       {
49422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49423       };
49424     } catch (...) {
49425       {
49426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49427       };
49428     }
49429   }
49430
49431
49432
49433 }
49434
49435
49436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49437   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49438   Dali::Vector< unsigned char >::SizeType arg2 ;
49439
49440   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49441   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49442   {
49443     try {
49444       (arg1)->Reserve(arg2);
49445     } catch (std::out_of_range& e) {
49446       {
49447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49448       };
49449     } catch (std::exception& e) {
49450       {
49451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49452       };
49453     } catch (Dali::DaliException e) {
49454       {
49455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49456       };
49457     } catch (...) {
49458       {
49459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49460       };
49461     }
49462   }
49463
49464 }
49465
49466
49467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49468   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49469   Dali::Vector< unsigned char >::SizeType arg2 ;
49470
49471   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49472   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49473   {
49474     try {
49475       (arg1)->Resize(arg2);
49476     } catch (std::out_of_range& e) {
49477       {
49478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49479       };
49480     } catch (std::exception& e) {
49481       {
49482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49483       };
49484     } catch (Dali::DaliException e) {
49485       {
49486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49487       };
49488     } catch (...) {
49489       {
49490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49491       };
49492     }
49493   }
49494
49495 }
49496
49497
49498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49499   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49500   Dali::Vector< unsigned char >::SizeType arg2 ;
49501   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49502   Dali::Vector< unsigned char >::ItemType temp3 ;
49503
49504   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49505   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49506   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49507   arg3 = &temp3;
49508   {
49509     try {
49510       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49511     } catch (std::out_of_range& e) {
49512       {
49513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49514       };
49515     } catch (std::exception& e) {
49516       {
49517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49518       };
49519     } catch (Dali::DaliException e) {
49520       {
49521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49522       };
49523     } catch (...) {
49524       {
49525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49526       };
49527     }
49528   }
49529
49530 }
49531
49532
49533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49534   void * jresult ;
49535   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49536   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49537   Dali::Vector< unsigned char >::Iterator result;
49538
49539   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49540   arg2 = jarg2;
49541   {
49542     try {
49543       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49544     } catch (std::out_of_range& e) {
49545       {
49546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49547       };
49548     } catch (std::exception& e) {
49549       {
49550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49551       };
49552     } catch (Dali::DaliException e) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49555       };
49556     } catch (...) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49559       };
49560     }
49561   }
49562
49563   jresult = (void *)result;
49564
49565
49566   return jresult;
49567 }
49568
49569
49570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49571   void * jresult ;
49572   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49573   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49574   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49575   Dali::Vector< unsigned char >::Iterator result;
49576
49577   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49578   arg2 = jarg2;
49579   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49580   {
49581     try {
49582       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49583     } catch (std::out_of_range& e) {
49584       {
49585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49586       };
49587     } catch (std::exception& e) {
49588       {
49589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (Dali::DaliException e) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49594       };
49595     } catch (...) {
49596       {
49597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49598       };
49599     }
49600   }
49601
49602   jresult = (void *)result;
49603
49604
49605   return jresult;
49606 }
49607
49608
49609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49610   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49611   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49612
49613   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49614   arg2 = jarg2;
49615   {
49616     try {
49617       (arg1)->Remove(arg2);
49618     } catch (std::out_of_range& e) {
49619       {
49620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49621       };
49622     } catch (std::exception& e) {
49623       {
49624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49625       };
49626     } catch (Dali::DaliException e) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49629       };
49630     } catch (...) {
49631       {
49632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49633       };
49634     }
49635   }
49636
49637
49638
49639 }
49640
49641
49642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49643   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49644   Dali::Vector< unsigned char > *arg2 = 0 ;
49645
49646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49647   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49648   if (!arg2) {
49649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49650     return ;
49651   }
49652   {
49653     try {
49654       (arg1)->Swap(*arg2);
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_VectorUnsignedChar_Clear(void * jarg1) {
49678   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49679
49680   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49681   {
49682     try {
49683       (arg1)->Clear();
49684     } catch (std::out_of_range& e) {
49685       {
49686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49687       };
49688     } catch (std::exception& e) {
49689       {
49690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49691       };
49692     } catch (Dali::DaliException e) {
49693       {
49694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49695       };
49696     } catch (...) {
49697       {
49698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49699       };
49700     }
49701   }
49702
49703 }
49704
49705
49706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49707   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49708
49709   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49710   {
49711     try {
49712       (arg1)->Release();
49713     } catch (std::out_of_range& e) {
49714       {
49715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (std::exception& e) {
49718       {
49719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49720       };
49721     } catch (Dali::DaliException e) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49724       };
49725     } catch (...) {
49726       {
49727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49728       };
49729     }
49730   }
49731
49732 }
49733
49734
49735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49736   int jresult ;
49737   int result;
49738
49739   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49740   jresult = (int)result;
49741   return jresult;
49742 }
49743
49744
49745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49746   void * jresult ;
49747   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49748
49749   {
49750     try {
49751       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49752     } catch (std::out_of_range& e) {
49753       {
49754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49755       };
49756     } catch (std::exception& e) {
49757       {
49758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49759       };
49760     } catch (Dali::DaliException e) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49763       };
49764     } catch (...) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49767       };
49768     }
49769   }
49770
49771   jresult = (void *)result;
49772   return jresult;
49773 }
49774
49775
49776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49777   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49778
49779   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49780   {
49781     try {
49782       delete arg1;
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49790       };
49791     } catch (Dali::DaliException e) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49794       };
49795     } catch (...) {
49796       {
49797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49798       };
49799     }
49800   }
49801
49802 }
49803
49804
49805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49806   void * jresult ;
49807   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49808   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49809
49810   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49811   if (!arg1) {
49812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49813     return 0;
49814   }
49815   {
49816     try {
49817       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49818     } catch (std::out_of_range& e) {
49819       {
49820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49821       };
49822     } catch (std::exception& e) {
49823       {
49824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49825       };
49826     } catch (Dali::DaliException e) {
49827       {
49828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49829       };
49830     } catch (...) {
49831       {
49832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49833       };
49834     }
49835   }
49836
49837   jresult = (void *)result;
49838   return jresult;
49839 }
49840
49841
49842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49843   void * jresult ;
49844   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49845   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49846   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49847
49848   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49849   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49850   if (!arg2) {
49851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49852     return 0;
49853   }
49854   {
49855     try {
49856       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49857     } catch (std::out_of_range& e) {
49858       {
49859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49860       };
49861     } catch (std::exception& e) {
49862       {
49863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49864       };
49865     } catch (Dali::DaliException e) {
49866       {
49867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49868       };
49869     } catch (...) {
49870       {
49871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49872       };
49873     }
49874   }
49875
49876   jresult = (void *)result;
49877   return jresult;
49878 }
49879
49880
49881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49882   void * jresult ;
49883   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49884   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49885
49886   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49887   {
49888     try {
49889       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49890     } catch (std::out_of_range& e) {
49891       {
49892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49893       };
49894     } catch (std::exception& e) {
49895       {
49896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49897       };
49898     } catch (Dali::DaliException e) {
49899       {
49900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49901       };
49902     } catch (...) {
49903       {
49904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49905       };
49906     }
49907   }
49908
49909   jresult = (void *)result;
49910   return jresult;
49911 }
49912
49913
49914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49915   void * jresult ;
49916   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49917   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49918
49919   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49920   {
49921     try {
49922       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49923     } catch (std::out_of_range& e) {
49924       {
49925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49926       };
49927     } catch (std::exception& e) {
49928       {
49929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49930       };
49931     } catch (Dali::DaliException e) {
49932       {
49933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49934       };
49935     } catch (...) {
49936       {
49937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49938       };
49939     }
49940   }
49941
49942   jresult = (void *)result;
49943   return jresult;
49944 }
49945
49946
49947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49948   void * jresult ;
49949   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49950   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49951   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49952
49953   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49954   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49955   {
49956     try {
49957       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49965       };
49966     } catch (Dali::DaliException e) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49969       };
49970     } catch (...) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49973       };
49974     }
49975   }
49976
49977   jresult = (void *)result;
49978   return jresult;
49979 }
49980
49981
49982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49983   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49984   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49985
49986   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49987   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49988   if (!arg2) {
49989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49990     return ;
49991   }
49992   {
49993     try {
49994       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49995     } catch (std::out_of_range& e) {
49996       {
49997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49998       };
49999     } catch (std::exception& e) {
50000       {
50001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50002       };
50003     } catch (Dali::DaliException e) {
50004       {
50005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50006       };
50007     } catch (...) {
50008       {
50009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50010       };
50011     }
50012   }
50013
50014 }
50015
50016
50017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50018   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50019   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50020   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50021
50022   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50023   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50024   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50025   if (!arg3) {
50026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50027     return ;
50028   }
50029   {
50030     try {
50031       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50032     } catch (std::out_of_range& e) {
50033       {
50034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50035       };
50036     } catch (std::exception& e) {
50037       {
50038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50039       };
50040     } catch (Dali::DaliException e) {
50041       {
50042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50043       };
50044     } catch (...) {
50045       {
50046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50047       };
50048     }
50049   }
50050
50051 }
50052
50053
50054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50055   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50056   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50057   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50058   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50059
50060   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50061   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50062   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50063   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50064   {
50065     try {
50066       (arg1)->Insert(arg2,arg3,arg4);
50067     } catch (std::out_of_range& e) {
50068       {
50069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50070       };
50071     } catch (std::exception& e) {
50072       {
50073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50074       };
50075     } catch (Dali::DaliException e) {
50076       {
50077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50078       };
50079     } catch (...) {
50080       {
50081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50082       };
50083     }
50084   }
50085
50086 }
50087
50088
50089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50090   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50091   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50092
50093   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50094   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50095   {
50096     try {
50097       (arg1)->Reserve(arg2);
50098     } catch (std::out_of_range& e) {
50099       {
50100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50101       };
50102     } catch (std::exception& e) {
50103       {
50104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50105       };
50106     } catch (Dali::DaliException e) {
50107       {
50108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50109       };
50110     } catch (...) {
50111       {
50112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50113       };
50114     }
50115   }
50116
50117 }
50118
50119
50120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50121   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50122   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50123
50124   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50125   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50126   {
50127     try {
50128       (arg1)->Resize(arg2);
50129     } catch (std::out_of_range& e) {
50130       {
50131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50132       };
50133     } catch (std::exception& e) {
50134       {
50135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50136       };
50137     } catch (Dali::DaliException e) {
50138       {
50139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50140       };
50141     } catch (...) {
50142       {
50143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50144       };
50145     }
50146   }
50147
50148 }
50149
50150
50151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50152   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50153   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50154   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50155
50156   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50157   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50158   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50159   if (!arg3) {
50160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50161     return ;
50162   }
50163   {
50164     try {
50165       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50166     } catch (std::out_of_range& e) {
50167       {
50168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50169       };
50170     } catch (std::exception& e) {
50171       {
50172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50173       };
50174     } catch (Dali::DaliException e) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50177       };
50178     } catch (...) {
50179       {
50180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50181       };
50182     }
50183   }
50184
50185 }
50186
50187
50188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50189   void * jresult ;
50190   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50191   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50192   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50193
50194   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50195   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50196   {
50197     try {
50198       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50199     } catch (std::out_of_range& e) {
50200       {
50201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50202       };
50203     } catch (std::exception& e) {
50204       {
50205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50206       };
50207     } catch (Dali::DaliException e) {
50208       {
50209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50210       };
50211     } catch (...) {
50212       {
50213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50214       };
50215     }
50216   }
50217
50218   jresult = (void *)result;
50219   return jresult;
50220 }
50221
50222
50223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50224   void * jresult ;
50225   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50226   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50227   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50228   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50229
50230   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50231   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50232   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50233   {
50234     try {
50235       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50236     } catch (std::out_of_range& e) {
50237       {
50238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50239       };
50240     } catch (std::exception& e) {
50241       {
50242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50243       };
50244     } catch (Dali::DaliException e) {
50245       {
50246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50247       };
50248     } catch (...) {
50249       {
50250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50251       };
50252     }
50253   }
50254
50255   jresult = (void *)result;
50256   return jresult;
50257 }
50258
50259
50260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50261   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50262   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50263
50264   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50265   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50266   {
50267     try {
50268       (arg1)->Remove(arg2);
50269     } catch (std::out_of_range& e) {
50270       {
50271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50272       };
50273     } catch (std::exception& e) {
50274       {
50275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50276       };
50277     } catch (Dali::DaliException e) {
50278       {
50279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50280       };
50281     } catch (...) {
50282       {
50283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50284       };
50285     }
50286   }
50287
50288 }
50289
50290
50291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50292   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50293   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50294
50295   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50296   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50297   if (!arg2) {
50298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50299     return ;
50300   }
50301   {
50302     try {
50303       (arg1)->Swap(*arg2);
50304     } catch (std::out_of_range& e) {
50305       {
50306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50307       };
50308     } catch (std::exception& e) {
50309       {
50310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50311       };
50312     } catch (Dali::DaliException e) {
50313       {
50314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50315       };
50316     } catch (...) {
50317       {
50318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50319       };
50320     }
50321   }
50322
50323 }
50324
50325
50326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50327   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50328
50329   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50330   {
50331     try {
50332       (arg1)->Clear();
50333     } catch (std::out_of_range& e) {
50334       {
50335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50336       };
50337     } catch (std::exception& e) {
50338       {
50339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50340       };
50341     } catch (Dali::DaliException e) {
50342       {
50343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50344       };
50345     } catch (...) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50348       };
50349     }
50350   }
50351
50352 }
50353
50354
50355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50356   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50357
50358   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50359   {
50360     try {
50361       (arg1)->Release();
50362     } catch (std::out_of_range& e) {
50363       {
50364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50365       };
50366     } catch (std::exception& e) {
50367       {
50368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50369       };
50370     } catch (Dali::DaliException e) {
50371       {
50372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50373       };
50374     } catch (...) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50377       };
50378     }
50379   }
50380
50381 }
50382
50383
50384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50385   void * jresult ;
50386   Dali::Signal< void () > *result = 0 ;
50387
50388   {
50389     try {
50390       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50391     } catch (std::out_of_range& e) {
50392       {
50393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50394       };
50395     } catch (std::exception& e) {
50396       {
50397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50398       };
50399     } catch (Dali::DaliException e) {
50400       {
50401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50402       };
50403     } catch (...) {
50404       {
50405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50406       };
50407     }
50408   }
50409
50410   jresult = (void *)result;
50411   return jresult;
50412 }
50413
50414
50415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50416   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50417
50418   arg1 = (Dali::Signal< void () > *)jarg1;
50419   {
50420     try {
50421       delete arg1;
50422     } catch (std::out_of_range& e) {
50423       {
50424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50425       };
50426     } catch (std::exception& e) {
50427       {
50428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50429       };
50430     } catch (Dali::DaliException e) {
50431       {
50432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50433       };
50434     } catch (...) {
50435       {
50436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50437       };
50438     }
50439   }
50440
50441 }
50442
50443
50444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50445   unsigned int jresult ;
50446   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50447   bool result;
50448
50449   arg1 = (Dali::Signal< void () > *)jarg1;
50450   {
50451     try {
50452       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50453     } catch (std::out_of_range& e) {
50454       {
50455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (std::exception& e) {
50458       {
50459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50460       };
50461     } catch (Dali::DaliException e) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50468       };
50469     }
50470   }
50471
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50478   unsigned long jresult ;
50479   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50480   std::size_t result;
50481
50482   arg1 = (Dali::Signal< void () > *)jarg1;
50483   {
50484     try {
50485       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50486     } catch (std::out_of_range& e) {
50487       {
50488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50489       };
50490     } catch (std::exception& e) {
50491       {
50492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50493       };
50494     } catch (Dali::DaliException e) {
50495       {
50496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50497       };
50498     } catch (...) {
50499       {
50500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50501       };
50502     }
50503   }
50504
50505   jresult = (unsigned long)result;
50506   return jresult;
50507 }
50508
50509
50510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50511   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50512   void (*arg2)() = (void (*)()) 0 ;
50513
50514   arg1 = (Dali::Signal< void () > *)jarg1;
50515   arg2 = (void (*)())jarg2;
50516   {
50517     try {
50518       (arg1)->Connect(arg2);
50519     } catch (std::out_of_range& e) {
50520       {
50521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50522       };
50523     } catch (std::exception& e) {
50524       {
50525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50526       };
50527     } catch (Dali::DaliException e) {
50528       {
50529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50530       };
50531     } catch (...) {
50532       {
50533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50534       };
50535     }
50536   }
50537
50538 }
50539
50540
50541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50542   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50543   void (*arg2)() = (void (*)()) 0 ;
50544
50545   arg1 = (Dali::Signal< void () > *)jarg1;
50546   arg2 = (void (*)())jarg2;
50547   {
50548     try {
50549       (arg1)->Disconnect(arg2);
50550     } catch (std::out_of_range& e) {
50551       {
50552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50553       };
50554     } catch (std::exception& e) {
50555       {
50556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50557       };
50558     } catch (Dali::DaliException e) {
50559       {
50560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50561       };
50562     } catch (...) {
50563       {
50564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50565       };
50566     }
50567   }
50568
50569 }
50570
50571
50572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50573   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50574   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50575   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50576
50577   arg1 = (Dali::Signal< void () > *)jarg1;
50578   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50579   arg3 = (Dali::FunctorDelegate *)jarg3;
50580   {
50581     try {
50582       (arg1)->Connect(arg2,arg3);
50583     } catch (std::out_of_range& e) {
50584       {
50585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50586       };
50587     } catch (std::exception& e) {
50588       {
50589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50590       };
50591     } catch (Dali::DaliException e) {
50592       {
50593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50594       };
50595     } catch (...) {
50596       {
50597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50598       };
50599     }
50600   }
50601
50602 }
50603
50604
50605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50606   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50607
50608   arg1 = (Dali::Signal< void () > *)jarg1;
50609   {
50610     try {
50611       (arg1)->Emit();
50612     } catch (std::out_of_range& e) {
50613       {
50614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50615       };
50616     } catch (std::exception& e) {
50617       {
50618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50619       };
50620     } catch (Dali::DaliException e) {
50621       {
50622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50623       };
50624     } catch (...) {
50625       {
50626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50627       };
50628     }
50629   }
50630
50631 }
50632
50633
50634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50635   unsigned int jresult ;
50636   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50637   bool result;
50638
50639   arg1 = (Dali::Signal< void (float) > *)jarg1;
50640   {
50641     try {
50642       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50643     } catch (std::out_of_range& e) {
50644       {
50645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50646       };
50647     } catch (std::exception& e) {
50648       {
50649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50650       };
50651     } catch (Dali::DaliException e) {
50652       {
50653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50654       };
50655     } catch (...) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50658       };
50659     }
50660   }
50661
50662   jresult = result;
50663   return jresult;
50664 }
50665
50666
50667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50668   unsigned long jresult ;
50669   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50670   std::size_t result;
50671
50672   arg1 = (Dali::Signal< void (float) > *)jarg1;
50673   {
50674     try {
50675       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50676     } catch (std::out_of_range& e) {
50677       {
50678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50679       };
50680     } catch (std::exception& e) {
50681       {
50682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50683       };
50684     } catch (Dali::DaliException e) {
50685       {
50686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50687       };
50688     } catch (...) {
50689       {
50690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50691       };
50692     }
50693   }
50694
50695   jresult = (unsigned long)result;
50696   return jresult;
50697 }
50698
50699
50700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50701   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50702   void (*arg2)(float) = (void (*)(float)) 0 ;
50703
50704   arg1 = (Dali::Signal< void (float) > *)jarg1;
50705   arg2 = (void (*)(float))jarg2;
50706   {
50707     try {
50708       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50709     } catch (std::out_of_range& e) {
50710       {
50711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50712       };
50713     } catch (std::exception& e) {
50714       {
50715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (Dali::DaliException e) {
50718       {
50719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50720       };
50721     } catch (...) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50724       };
50725     }
50726   }
50727
50728 }
50729
50730
50731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50732   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50733   void (*arg2)(float) = (void (*)(float)) 0 ;
50734
50735   arg1 = (Dali::Signal< void (float) > *)jarg1;
50736   arg2 = (void (*)(float))jarg2;
50737   {
50738     try {
50739       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50740     } catch (std::out_of_range& e) {
50741       {
50742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50743       };
50744     } catch (std::exception& e) {
50745       {
50746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50747       };
50748     } catch (Dali::DaliException e) {
50749       {
50750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50751       };
50752     } catch (...) {
50753       {
50754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50755       };
50756     }
50757   }
50758
50759 }
50760
50761
50762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50763   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50764   float arg2 ;
50765
50766   arg1 = (Dali::Signal< void (float) > *)jarg1;
50767   arg2 = (float)jarg2;
50768   {
50769     try {
50770       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50771     } catch (std::out_of_range& e) {
50772       {
50773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50774       };
50775     } catch (std::exception& e) {
50776       {
50777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50778       };
50779     } catch (Dali::DaliException e) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50782       };
50783     } catch (...) {
50784       {
50785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50786       };
50787     }
50788   }
50789
50790 }
50791
50792
50793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50794   void * jresult ;
50795   Dali::Signal< void (float) > *result = 0 ;
50796
50797   {
50798     try {
50799       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50800     } catch (std::out_of_range& e) {
50801       {
50802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (std::exception& e) {
50805       {
50806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50807       };
50808     } catch (Dali::DaliException e) {
50809       {
50810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50811       };
50812     } catch (...) {
50813       {
50814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50815       };
50816     }
50817   }
50818
50819   jresult = (void *)result;
50820   return jresult;
50821 }
50822
50823
50824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50825   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50826
50827   arg1 = (Dali::Signal< void (float) > *)jarg1;
50828   {
50829     try {
50830       delete arg1;
50831     } catch (std::out_of_range& e) {
50832       {
50833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50834       };
50835     } catch (std::exception& e) {
50836       {
50837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50838       };
50839     } catch (Dali::DaliException e) {
50840       {
50841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50842       };
50843     } catch (...) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50846       };
50847     }
50848   }
50849
50850 }
50851
50852
50853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50854   unsigned int jresult ;
50855   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50856   bool result;
50857
50858   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50859   {
50860     try {
50861       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50862     } catch (std::out_of_range& e) {
50863       {
50864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50865       };
50866     } catch (std::exception& e) {
50867       {
50868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50869       };
50870     } catch (Dali::DaliException e) {
50871       {
50872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50873       };
50874     } catch (...) {
50875       {
50876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50877       };
50878     }
50879   }
50880
50881   jresult = result;
50882   return jresult;
50883 }
50884
50885
50886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50887   unsigned long jresult ;
50888   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50889   std::size_t result;
50890
50891   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50892   {
50893     try {
50894       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50895     } catch (std::out_of_range& e) {
50896       {
50897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50898       };
50899     } catch (std::exception& e) {
50900       {
50901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50902       };
50903     } catch (Dali::DaliException e) {
50904       {
50905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50906       };
50907     } catch (...) {
50908       {
50909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50910       };
50911     }
50912   }
50913
50914   jresult = (unsigned long)result;
50915   return jresult;
50916 }
50917
50918
50919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50920   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50921   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50922
50923   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50924   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50925   {
50926     try {
50927       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50928     } catch (std::out_of_range& e) {
50929       {
50930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50931       };
50932     } catch (std::exception& e) {
50933       {
50934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50935       };
50936     } catch (Dali::DaliException e) {
50937       {
50938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50939       };
50940     } catch (...) {
50941       {
50942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50943       };
50944     }
50945   }
50946
50947 }
50948
50949
50950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50951   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50952   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50953
50954   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50955   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50956   {
50957     try {
50958       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50959     } catch (std::out_of_range& e) {
50960       {
50961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50962       };
50963     } catch (std::exception& e) {
50964       {
50965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50966       };
50967     } catch (Dali::DaliException e) {
50968       {
50969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50970       };
50971     } catch (...) {
50972       {
50973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50974       };
50975     }
50976   }
50977
50978 }
50979
50980
50981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50982   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50983   Dali::BaseHandle arg2 ;
50984   Dali::BaseHandle *argp2 ;
50985
50986   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50987   argp2 = (Dali::BaseHandle *)jarg2;
50988   if (!argp2) {
50989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50990     return ;
50991   }
50992   arg2 = *argp2;
50993   {
50994     try {
50995       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51011       };
51012     }
51013   }
51014
51015 }
51016
51017
51018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51019   void * jresult ;
51020   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51021
51022   {
51023     try {
51024       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51025     } catch (std::out_of_range& e) {
51026       {
51027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51028       };
51029     } catch (std::exception& e) {
51030       {
51031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51032       };
51033     } catch (Dali::DaliException e) {
51034       {
51035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51036       };
51037     } catch (...) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51040       };
51041     }
51042   }
51043
51044   jresult = (void *)result;
51045   return jresult;
51046 }
51047
51048
51049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51050   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51051
51052   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51053   {
51054     try {
51055       delete arg1;
51056     } catch (std::out_of_range& e) {
51057       {
51058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51059       };
51060     } catch (std::exception& e) {
51061       {
51062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51063       };
51064     } catch (Dali::DaliException e) {
51065       {
51066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51067       };
51068     } catch (...) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51071       };
51072     }
51073   }
51074
51075 }
51076
51077
51078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51079   unsigned int jresult ;
51080   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51081   bool result;
51082
51083   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51084   {
51085     try {
51086       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51087     } catch (std::out_of_range& e) {
51088       {
51089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51090       };
51091     } catch (std::exception& e) {
51092       {
51093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51094       };
51095     } catch (Dali::DaliException e) {
51096       {
51097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51098       };
51099     } catch (...) {
51100       {
51101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51102       };
51103     }
51104   }
51105
51106   jresult = result;
51107   return jresult;
51108 }
51109
51110
51111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51112   unsigned long jresult ;
51113   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51114   std::size_t result;
51115
51116   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51117   {
51118     try {
51119       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51120     } catch (std::out_of_range& e) {
51121       {
51122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51123       };
51124     } catch (std::exception& e) {
51125       {
51126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51127       };
51128     } catch (Dali::DaliException e) {
51129       {
51130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51131       };
51132     } catch (...) {
51133       {
51134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51135       };
51136     }
51137   }
51138
51139   jresult = (unsigned long)result;
51140   return jresult;
51141 }
51142
51143
51144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51145   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51146   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51147
51148   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51149   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51150   {
51151     try {
51152       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51153     } catch (std::out_of_range& e) {
51154       {
51155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51156       };
51157     } catch (std::exception& e) {
51158       {
51159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (Dali::DaliException e) {
51162       {
51163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51164       };
51165     } catch (...) {
51166       {
51167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51168       };
51169     }
51170   }
51171
51172 }
51173
51174
51175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51176   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51177   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51178
51179   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51180   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51181   {
51182     try {
51183       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51184     } catch (std::out_of_range& e) {
51185       {
51186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51187       };
51188     } catch (std::exception& e) {
51189       {
51190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51191       };
51192     } catch (Dali::DaliException e) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51195       };
51196     } catch (...) {
51197       {
51198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51199       };
51200     }
51201   }
51202
51203 }
51204
51205
51206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51207   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51208   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51209
51210   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51211   arg2 = (Dali::RefObject *)jarg2;
51212   {
51213     try {
51214       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51215     } catch (std::out_of_range& e) {
51216       {
51217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51218       };
51219     } catch (std::exception& e) {
51220       {
51221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51222       };
51223     } catch (Dali::DaliException e) {
51224       {
51225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51226       };
51227     } catch (...) {
51228       {
51229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51230       };
51231     }
51232   }
51233
51234 }
51235
51236
51237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51238   void * jresult ;
51239   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51240
51241   {
51242     try {
51243       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51244     } catch (std::out_of_range& e) {
51245       {
51246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51247       };
51248     } catch (std::exception& e) {
51249       {
51250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51251       };
51252     } catch (Dali::DaliException e) {
51253       {
51254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51255       };
51256     } catch (...) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51259       };
51260     }
51261   }
51262
51263   jresult = (void *)result;
51264   return jresult;
51265 }
51266
51267
51268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51269   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51270
51271   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51272   {
51273     try {
51274       delete arg1;
51275     } catch (std::out_of_range& e) {
51276       {
51277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51278       };
51279     } catch (std::exception& e) {
51280       {
51281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51282       };
51283     } catch (Dali::DaliException e) {
51284       {
51285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51286       };
51287     } catch (...) {
51288       {
51289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51290       };
51291     }
51292   }
51293
51294 }
51295
51296
51297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51298   unsigned int jresult ;
51299   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51300   bool result;
51301
51302   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51303   {
51304     try {
51305       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51306     } catch (std::out_of_range& e) {
51307       {
51308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51309       };
51310     } catch (std::exception& e) {
51311       {
51312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51313       };
51314     } catch (Dali::DaliException e) {
51315       {
51316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51317       };
51318     } catch (...) {
51319       {
51320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51321       };
51322     }
51323   }
51324
51325   jresult = result;
51326   return jresult;
51327 }
51328
51329
51330 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51331   unsigned long jresult ;
51332   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51333   std::size_t result;
51334
51335   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51336   {
51337     try {
51338       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51339     } catch (std::out_of_range& e) {
51340       {
51341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51342       };
51343     } catch (std::exception& e) {
51344       {
51345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51346       };
51347     } catch (Dali::DaliException e) {
51348       {
51349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51350       };
51351     } catch (...) {
51352       {
51353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51354       };
51355     }
51356   }
51357
51358   jresult = (unsigned long)result;
51359   return jresult;
51360 }
51361
51362
51363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51364   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51365   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51366
51367   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51368   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51369   {
51370     try {
51371       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51372     } catch (std::out_of_range& e) {
51373       {
51374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (std::exception& e) {
51377       {
51378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51379       };
51380     } catch (Dali::DaliException e) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51383       };
51384     } catch (...) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51387       };
51388     }
51389   }
51390
51391 }
51392
51393
51394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51395   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51396   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51397
51398   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51399   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51400   {
51401     try {
51402       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51426   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51427   Dali::PropertyNotification *arg2 = 0 ;
51428
51429   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51430   arg2 = (Dali::PropertyNotification *)jarg2;
51431   if (!arg2) {
51432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51433     return ;
51434   }
51435   {
51436     try {
51437       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (Dali::DaliException e) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51453       };
51454     }
51455   }
51456
51457 }
51458
51459
51460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51461   void * jresult ;
51462   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51463
51464   {
51465     try {
51466       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51467     } catch (std::out_of_range& e) {
51468       {
51469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51470       };
51471     } catch (std::exception& e) {
51472       {
51473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51474       };
51475     } catch (Dali::DaliException e) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51478       };
51479     } catch (...) {
51480       {
51481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51482       };
51483     }
51484   }
51485
51486   jresult = (void *)result;
51487   return jresult;
51488 }
51489
51490
51491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51492   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51493
51494   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51495   {
51496     try {
51497       delete arg1;
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 void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51521   void * jresult ;
51522   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51523
51524   {
51525     try {
51526       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51527     } catch (std::out_of_range& e) {
51528       {
51529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51530       };
51531     } catch (std::exception& e) {
51532       {
51533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51534       };
51535     } catch (Dali::DaliException e) {
51536       {
51537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51538       };
51539     } catch (...) {
51540       {
51541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51542       };
51543     }
51544   }
51545
51546   jresult = (void *)result;
51547   return jresult;
51548 }
51549
51550
51551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51552   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51553
51554   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51555   {
51556     try {
51557       delete arg1;
51558     } catch (std::out_of_range& e) {
51559       {
51560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51561       };
51562     } catch (std::exception& e) {
51563       {
51564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51565       };
51566     } catch (Dali::DaliException e) {
51567       {
51568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51569       };
51570     } catch (...) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51573       };
51574     }
51575   }
51576
51577 }
51578
51579
51580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51581   unsigned int jresult ;
51582   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51583   bool result;
51584
51585   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51586   {
51587     try {
51588       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);
51589     } catch (std::out_of_range& e) {
51590       {
51591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51592       };
51593     } catch (std::exception& e) {
51594       {
51595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51596       };
51597     } catch (Dali::DaliException e) {
51598       {
51599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51600       };
51601     } catch (...) {
51602       {
51603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51604       };
51605     }
51606   }
51607
51608   jresult = result;
51609   return jresult;
51610 }
51611
51612
51613 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51614   unsigned long jresult ;
51615   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51616   std::size_t result;
51617
51618   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51619   {
51620     try {
51621       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);
51622     } catch (std::out_of_range& e) {
51623       {
51624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51625       };
51626     } catch (std::exception& e) {
51627       {
51628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51629       };
51630     } catch (Dali::DaliException e) {
51631       {
51632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51633       };
51634     } catch (...) {
51635       {
51636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51637       };
51638     }
51639   }
51640
51641   jresult = (unsigned long)result;
51642   return jresult;
51643 }
51644
51645
51646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51647   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51648   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51649
51650   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51651   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51652   {
51653     try {
51654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51655     } catch (std::out_of_range& e) {
51656       {
51657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51658       };
51659     } catch (std::exception& e) {
51660       {
51661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51662       };
51663     } catch (Dali::DaliException e) {
51664       {
51665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51666       };
51667     } catch (...) {
51668       {
51669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51670       };
51671     }
51672   }
51673
51674 }
51675
51676
51677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51678   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51679   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51680
51681   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51682   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51683   {
51684     try {
51685       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51686     } catch (std::out_of_range& e) {
51687       {
51688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51689       };
51690     } catch (std::exception& e) {
51691       {
51692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51693       };
51694     } catch (Dali::DaliException e) {
51695       {
51696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51697       };
51698     } catch (...) {
51699       {
51700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51701       };
51702     }
51703   }
51704
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51709   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51710   Dali::Actor arg2 ;
51711   Dali::LongPressGesture *arg3 = 0 ;
51712   Dali::Actor *argp2 ;
51713
51714   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51715   argp2 = (Dali::Actor *)jarg2;
51716   if (!argp2) {
51717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51718     return ;
51719   }
51720   arg2 = *argp2;
51721   arg3 = (Dali::LongPressGesture *)jarg3;
51722   if (!arg3) {
51723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51724     return ;
51725   }
51726   {
51727     try {
51728       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51729     } catch (std::out_of_range& e) {
51730       {
51731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51732       };
51733     } catch (std::exception& e) {
51734       {
51735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51736       };
51737     } catch (Dali::DaliException e) {
51738       {
51739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51740       };
51741     } catch (...) {
51742       {
51743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51744       };
51745     }
51746   }
51747
51748 }
51749
51750
51751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51752   void * jresult ;
51753   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51754
51755   {
51756     try {
51757       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51758     } catch (std::out_of_range& e) {
51759       {
51760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51761       };
51762     } catch (std::exception& e) {
51763       {
51764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51765       };
51766     } catch (Dali::DaliException e) {
51767       {
51768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51769       };
51770     } catch (...) {
51771       {
51772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51773       };
51774     }
51775   }
51776
51777   jresult = (void *)result;
51778   return jresult;
51779 }
51780
51781
51782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51783   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51784
51785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51786   {
51787     try {
51788       delete arg1;
51789     } catch (std::out_of_range& e) {
51790       {
51791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51792       };
51793     } catch (std::exception& e) {
51794       {
51795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51796       };
51797     } catch (Dali::DaliException e) {
51798       {
51799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51800       };
51801     } catch (...) {
51802       {
51803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51804       };
51805     }
51806   }
51807
51808 }
51809
51810
51811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51812   unsigned int jresult ;
51813   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51814   bool result;
51815
51816   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51817   {
51818     try {
51819       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);
51820     } catch (std::out_of_range& e) {
51821       {
51822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (std::exception& e) {
51825       {
51826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51827       };
51828     } catch (Dali::DaliException e) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51831       };
51832     } catch (...) {
51833       {
51834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51835       };
51836     }
51837   }
51838
51839   jresult = result;
51840   return jresult;
51841 }
51842
51843
51844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51845   unsigned long jresult ;
51846   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51847   std::size_t result;
51848
51849   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51850   {
51851     try {
51852       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);
51853     } catch (std::out_of_range& e) {
51854       {
51855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (std::exception& e) {
51858       {
51859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (Dali::DaliException e) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51864       };
51865     } catch (...) {
51866       {
51867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51868       };
51869     }
51870   }
51871
51872   jresult = (unsigned long)result;
51873   return jresult;
51874 }
51875
51876
51877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51878   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51879   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51880
51881   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51882   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51883   {
51884     try {
51885       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51893       };
51894     } catch (Dali::DaliException e) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51901       };
51902     }
51903   }
51904
51905 }
51906
51907
51908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51909   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51910   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51911
51912   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51913   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51914   {
51915     try {
51916       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51917     } catch (std::out_of_range& e) {
51918       {
51919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51920       };
51921     } catch (std::exception& e) {
51922       {
51923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51924       };
51925     } catch (Dali::DaliException e) {
51926       {
51927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51928       };
51929     } catch (...) {
51930       {
51931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51932       };
51933     }
51934   }
51935
51936 }
51937
51938
51939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51940   unsigned int jresult ;
51941   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51942   Dali::Actor arg2 ;
51943   Dali::TouchData *arg3 = 0 ;
51944   Dali::Actor *argp2 ;
51945   bool result;
51946
51947   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51948   argp2 = (Dali::Actor *)jarg2;
51949   if (!argp2) {
51950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51951     return 0;
51952   }
51953   arg2 = *argp2;
51954   arg3 = (Dali::TouchData *)jarg3;
51955   if (!arg3) {
51956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51957     return 0;
51958   }
51959   {
51960     try {
51961       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51962     } catch (std::out_of_range& e) {
51963       {
51964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51965       };
51966     } catch (std::exception& e) {
51967       {
51968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51969       };
51970     } catch (Dali::DaliException e) {
51971       {
51972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51973       };
51974     } catch (...) {
51975       {
51976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51977       };
51978     }
51979   }
51980
51981   jresult = result;
51982   return jresult;
51983 }
51984
51985
51986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51987   void * jresult ;
51988   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51989
51990   {
51991     try {
51992       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51993     } catch (std::out_of_range& e) {
51994       {
51995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51996       };
51997     } catch (std::exception& e) {
51998       {
51999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52000       };
52001     } catch (Dali::DaliException e) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52004       };
52005     } catch (...) {
52006       {
52007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52008       };
52009     }
52010   }
52011
52012   jresult = (void *)result;
52013   return jresult;
52014 }
52015
52016
52017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52018   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52019
52020   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52021   {
52022     try {
52023       delete arg1;
52024     } catch (std::out_of_range& e) {
52025       {
52026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (std::exception& e) {
52029       {
52030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52031       };
52032     } catch (Dali::DaliException e) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52035       };
52036     } catch (...) {
52037       {
52038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52039       };
52040     }
52041   }
52042
52043 }
52044
52045
52046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52047   unsigned int jresult ;
52048   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52049   bool result;
52050
52051   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52052   {
52053     try {
52054       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);
52055     } catch (std::out_of_range& e) {
52056       {
52057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52058       };
52059     } catch (std::exception& e) {
52060       {
52061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52062       };
52063     } catch (Dali::DaliException e) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52066       };
52067     } catch (...) {
52068       {
52069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52070       };
52071     }
52072   }
52073
52074   jresult = result;
52075   return jresult;
52076 }
52077
52078
52079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52080   unsigned long jresult ;
52081   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52082   std::size_t result;
52083
52084   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52085   {
52086     try {
52087       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);
52088     } catch (std::out_of_range& e) {
52089       {
52090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52091       };
52092     } catch (std::exception& e) {
52093       {
52094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52095       };
52096     } catch (Dali::DaliException e) {
52097       {
52098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52099       };
52100     } catch (...) {
52101       {
52102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52103       };
52104     }
52105   }
52106
52107   jresult = (unsigned long)result;
52108   return jresult;
52109 }
52110
52111
52112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52113   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52114   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52115
52116   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52117   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52118   {
52119     try {
52120       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52121     } catch (std::out_of_range& e) {
52122       {
52123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52124       };
52125     } catch (std::exception& e) {
52126       {
52127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52128       };
52129     } catch (Dali::DaliException e) {
52130       {
52131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52132       };
52133     } catch (...) {
52134       {
52135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52136       };
52137     }
52138   }
52139
52140 }
52141
52142
52143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52144   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52145   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52146
52147   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52148   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52149   {
52150     try {
52151       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52152     } catch (std::out_of_range& e) {
52153       {
52154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52155       };
52156     } catch (std::exception& e) {
52157       {
52158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52159       };
52160     } catch (Dali::DaliException e) {
52161       {
52162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52163       };
52164     } catch (...) {
52165       {
52166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52167       };
52168     }
52169   }
52170
52171 }
52172
52173
52174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52175   unsigned int jresult ;
52176   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52177   Dali::Actor arg2 ;
52178   Dali::HoverEvent *arg3 = 0 ;
52179   Dali::Actor *argp2 ;
52180   bool result;
52181
52182   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52183   argp2 = (Dali::Actor *)jarg2;
52184   if (!argp2) {
52185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52186     return 0;
52187   }
52188   arg2 = *argp2;
52189   arg3 = (Dali::HoverEvent *)jarg3;
52190   if (!arg3) {
52191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52192     return 0;
52193   }
52194   {
52195     try {
52196       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52197     } catch (std::out_of_range& e) {
52198       {
52199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (std::exception& e) {
52202       {
52203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52204       };
52205     } catch (Dali::DaliException e) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52208       };
52209     } catch (...) {
52210       {
52211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52212       };
52213     }
52214   }
52215
52216   jresult = result;
52217   return jresult;
52218 }
52219
52220
52221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52222   void * jresult ;
52223   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52224
52225   {
52226     try {
52227       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52228     } catch (std::out_of_range& e) {
52229       {
52230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52231       };
52232     } catch (std::exception& e) {
52233       {
52234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52235       };
52236     } catch (Dali::DaliException e) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52239       };
52240     } catch (...) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52243       };
52244     }
52245   }
52246
52247   jresult = (void *)result;
52248   return jresult;
52249 }
52250
52251
52252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52253   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52254
52255   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52256   {
52257     try {
52258       delete arg1;
52259     } catch (std::out_of_range& e) {
52260       {
52261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52262       };
52263     } catch (std::exception& e) {
52264       {
52265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52266       };
52267     } catch (Dali::DaliException e) {
52268       {
52269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52270       };
52271     } catch (...) {
52272       {
52273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52274       };
52275     }
52276   }
52277
52278 }
52279
52280
52281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52282   unsigned int jresult ;
52283   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52284   bool result;
52285
52286   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52287   {
52288     try {
52289       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);
52290     } catch (std::out_of_range& e) {
52291       {
52292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52293       };
52294     } catch (std::exception& e) {
52295       {
52296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52297       };
52298     } catch (Dali::DaliException e) {
52299       {
52300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52301       };
52302     } catch (...) {
52303       {
52304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52305       };
52306     }
52307   }
52308
52309   jresult = result;
52310   return jresult;
52311 }
52312
52313
52314 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52315   unsigned long jresult ;
52316   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52317   std::size_t result;
52318
52319   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52320   {
52321     try {
52322       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);
52323     } catch (std::out_of_range& e) {
52324       {
52325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52326       };
52327     } catch (std::exception& e) {
52328       {
52329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52330       };
52331     } catch (Dali::DaliException e) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52334       };
52335     } catch (...) {
52336       {
52337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52338       };
52339     }
52340   }
52341
52342   jresult = (unsigned long)result;
52343   return jresult;
52344 }
52345
52346
52347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52348   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52349   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52350
52351   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52352   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52353   {
52354     try {
52355       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52356     } catch (std::out_of_range& e) {
52357       {
52358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (std::exception& e) {
52361       {
52362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (Dali::DaliException e) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52367       };
52368     } catch (...) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52371       };
52372     }
52373   }
52374
52375 }
52376
52377
52378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52379   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52380   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52381
52382   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52383   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52384   {
52385     try {
52386       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52387     } catch (std::out_of_range& e) {
52388       {
52389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52390       };
52391     } catch (std::exception& e) {
52392       {
52393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52394       };
52395     } catch (Dali::DaliException e) {
52396       {
52397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52398       };
52399     } catch (...) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52402       };
52403     }
52404   }
52405
52406 }
52407
52408
52409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52410   unsigned int jresult ;
52411   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52412   Dali::Actor arg2 ;
52413   Dali::WheelEvent *arg3 = 0 ;
52414   Dali::Actor *argp2 ;
52415   bool result;
52416
52417   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52418   argp2 = (Dali::Actor *)jarg2;
52419   if (!argp2) {
52420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52421     return 0;
52422   }
52423   arg2 = *argp2;
52424   arg3 = (Dali::WheelEvent *)jarg3;
52425   if (!arg3) {
52426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52427     return 0;
52428   }
52429   {
52430     try {
52431       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52432     } catch (std::out_of_range& e) {
52433       {
52434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52435       };
52436     } catch (std::exception& e) {
52437       {
52438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52439       };
52440     } catch (Dali::DaliException e) {
52441       {
52442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52443       };
52444     } catch (...) {
52445       {
52446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52447       };
52448     }
52449   }
52450
52451   jresult = result;
52452   return jresult;
52453 }
52454
52455
52456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52457   void * jresult ;
52458   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52459
52460   {
52461     try {
52462       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52463     } catch (std::out_of_range& e) {
52464       {
52465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52466       };
52467     } catch (std::exception& e) {
52468       {
52469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (Dali::DaliException e) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52474       };
52475     } catch (...) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52478       };
52479     }
52480   }
52481
52482   jresult = (void *)result;
52483   return jresult;
52484 }
52485
52486
52487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52488   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52489
52490   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52491   {
52492     try {
52493       delete arg1;
52494     } catch (std::out_of_range& e) {
52495       {
52496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52497       };
52498     } catch (std::exception& e) {
52499       {
52500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52501       };
52502     } catch (Dali::DaliException e) {
52503       {
52504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52505       };
52506     } catch (...) {
52507       {
52508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52509       };
52510     }
52511   }
52512
52513 }
52514
52515
52516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52517   unsigned int jresult ;
52518   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52519   bool result;
52520
52521   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52522   {
52523     try {
52524       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52525     } catch (std::out_of_range& e) {
52526       {
52527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52528       };
52529     } catch (std::exception& e) {
52530       {
52531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52532       };
52533     } catch (Dali::DaliException e) {
52534       {
52535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52536       };
52537     } catch (...) {
52538       {
52539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52540       };
52541     }
52542   }
52543
52544   jresult = result;
52545   return jresult;
52546 }
52547
52548
52549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52550   unsigned long jresult ;
52551   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52552   std::size_t result;
52553
52554   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52555   {
52556     try {
52557       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52558     } catch (std::out_of_range& e) {
52559       {
52560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52561       };
52562     } catch (std::exception& e) {
52563       {
52564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52565       };
52566     } catch (Dali::DaliException e) {
52567       {
52568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52569       };
52570     } catch (...) {
52571       {
52572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52573       };
52574     }
52575   }
52576
52577   jresult = (unsigned long)result;
52578   return jresult;
52579 }
52580
52581
52582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52583   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52584   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52585
52586   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52587   arg2 = (void (*)(Dali::Actor))jarg2;
52588   {
52589     try {
52590       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52591     } catch (std::out_of_range& e) {
52592       {
52593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52594       };
52595     } catch (std::exception& e) {
52596       {
52597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52598       };
52599     } catch (Dali::DaliException e) {
52600       {
52601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52602       };
52603     } catch (...) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52606       };
52607     }
52608   }
52609
52610 }
52611
52612
52613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52614   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52615   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52616
52617   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52618   arg2 = (void (*)(Dali::Actor))jarg2;
52619   {
52620     try {
52621       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52622     } catch (std::out_of_range& e) {
52623       {
52624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52625       };
52626     } catch (std::exception& e) {
52627       {
52628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52629       };
52630     } catch (Dali::DaliException e) {
52631       {
52632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52633       };
52634     } catch (...) {
52635       {
52636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52637       };
52638     }
52639   }
52640
52641 }
52642
52643
52644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52645   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52646   Dali::Actor arg2 ;
52647   Dali::Actor *argp2 ;
52648
52649   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52650   argp2 = (Dali::Actor *)jarg2;
52651   if (!argp2) {
52652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52653     return ;
52654   }
52655   arg2 = *argp2;
52656   {
52657     try {
52658       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52659     } catch (std::out_of_range& e) {
52660       {
52661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52662       };
52663     } catch (std::exception& e) {
52664       {
52665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52666       };
52667     } catch (Dali::DaliException e) {
52668       {
52669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52670       };
52671     } catch (...) {
52672       {
52673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52674       };
52675     }
52676   }
52677
52678 }
52679
52680
52681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52682   void * jresult ;
52683   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52684
52685   {
52686     try {
52687       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52688     } catch (std::out_of_range& e) {
52689       {
52690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52691       };
52692     } catch (std::exception& e) {
52693       {
52694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52695       };
52696     } catch (Dali::DaliException e) {
52697       {
52698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52699       };
52700     } catch (...) {
52701       {
52702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52703       };
52704     }
52705   }
52706
52707   jresult = (void *)result;
52708   return jresult;
52709 }
52710
52711
52712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52713   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52714
52715   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52716   {
52717     try {
52718       delete arg1;
52719     } catch (std::out_of_range& e) {
52720       {
52721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52722       };
52723     } catch (std::exception& e) {
52724       {
52725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52726       };
52727     } catch (Dali::DaliException e) {
52728       {
52729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52730       };
52731     } catch (...) {
52732       {
52733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52734       };
52735     }
52736   }
52737
52738 }
52739
52740
52741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52742   unsigned int jresult ;
52743   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52744   bool result;
52745
52746   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52747   {
52748     try {
52749       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52750     } catch (std::out_of_range& e) {
52751       {
52752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52753       };
52754     } catch (std::exception& e) {
52755       {
52756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52757       };
52758     } catch (Dali::DaliException e) {
52759       {
52760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52761       };
52762     } catch (...) {
52763       {
52764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52765       };
52766     }
52767   }
52768
52769   jresult = result;
52770   return jresult;
52771 }
52772
52773
52774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52775   unsigned long jresult ;
52776   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52777   std::size_t result;
52778
52779   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52780   {
52781     try {
52782       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52790       };
52791     } catch (Dali::DaliException e) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52794       };
52795     } catch (...) {
52796       {
52797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52798       };
52799     }
52800   }
52801
52802   jresult = (unsigned long)result;
52803   return jresult;
52804 }
52805
52806
52807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52808   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52809   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52810
52811   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52812   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52813   {
52814     try {
52815       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52816     } catch (std::out_of_range& e) {
52817       {
52818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52819       };
52820     } catch (std::exception& e) {
52821       {
52822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52823       };
52824     } catch (Dali::DaliException e) {
52825       {
52826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52827       };
52828     } catch (...) {
52829       {
52830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52831       };
52832     }
52833   }
52834
52835 }
52836
52837
52838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52839   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52840   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52841
52842   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52843   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52844   {
52845     try {
52846       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52847     } catch (std::out_of_range& e) {
52848       {
52849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52850       };
52851     } catch (std::exception& e) {
52852       {
52853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52854       };
52855     } catch (Dali::DaliException e) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52858       };
52859     } catch (...) {
52860       {
52861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52862       };
52863     }
52864   }
52865
52866 }
52867
52868
52869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52870   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52871   Dali::KeyEvent *arg2 = 0 ;
52872
52873   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52874   arg2 = (Dali::KeyEvent *)jarg2;
52875   if (!arg2) {
52876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52877     return ;
52878   }
52879   {
52880     try {
52881       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52882     } catch (std::out_of_range& e) {
52883       {
52884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52885       };
52886     } catch (std::exception& e) {
52887       {
52888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52889       };
52890     } catch (Dali::DaliException e) {
52891       {
52892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52893       };
52894     } catch (...) {
52895       {
52896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52897       };
52898     }
52899   }
52900
52901 }
52902
52903
52904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52905   void * jresult ;
52906   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52907
52908   {
52909     try {
52910       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52911     } catch (std::out_of_range& e) {
52912       {
52913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52914       };
52915     } catch (std::exception& e) {
52916       {
52917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52918       };
52919     } catch (Dali::DaliException e) {
52920       {
52921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52922       };
52923     } catch (...) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52926       };
52927     }
52928   }
52929
52930   jresult = (void *)result;
52931   return jresult;
52932 }
52933
52934
52935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52936   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52937
52938   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52939   {
52940     try {
52941       delete arg1;
52942     } catch (std::out_of_range& e) {
52943       {
52944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52945       };
52946     } catch (std::exception& e) {
52947       {
52948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52949       };
52950     } catch (Dali::DaliException e) {
52951       {
52952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52953       };
52954     } catch (...) {
52955       {
52956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52957       };
52958     }
52959   }
52960
52961 }
52962
52963
52964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52965   unsigned int jresult ;
52966   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52967   bool result;
52968
52969   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52970   {
52971     try {
52972       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52988       };
52989     }
52990   }
52991
52992   jresult = result;
52993   return jresult;
52994 }
52995
52996
52997 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52998   unsigned long jresult ;
52999   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53000   std::size_t result;
53001
53002   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53003   {
53004     try {
53005       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53006     } catch (std::out_of_range& e) {
53007       {
53008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53009       };
53010     } catch (std::exception& e) {
53011       {
53012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53013       };
53014     } catch (Dali::DaliException e) {
53015       {
53016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53017       };
53018     } catch (...) {
53019       {
53020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53021       };
53022     }
53023   }
53024
53025   jresult = (unsigned long)result;
53026   return jresult;
53027 }
53028
53029
53030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53031   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53032   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53033
53034   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53035   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53036   {
53037     try {
53038       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53039     } catch (std::out_of_range& e) {
53040       {
53041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53042       };
53043     } catch (std::exception& e) {
53044       {
53045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53046       };
53047     } catch (Dali::DaliException e) {
53048       {
53049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53050       };
53051     } catch (...) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53054       };
53055     }
53056   }
53057
53058 }
53059
53060
53061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53062   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53063   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53064
53065   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53066   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53067   {
53068     try {
53069       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53070     } catch (std::out_of_range& e) {
53071       {
53072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53073       };
53074     } catch (std::exception& e) {
53075       {
53076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53077       };
53078     } catch (Dali::DaliException e) {
53079       {
53080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53085       };
53086     }
53087   }
53088
53089 }
53090
53091
53092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53093   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53094   Dali::TouchData *arg2 = 0 ;
53095
53096   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53097   arg2 = (Dali::TouchData *)jarg2;
53098   if (!arg2) {
53099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
53100     return ;
53101   }
53102   {
53103     try {
53104       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
53105     } catch (std::out_of_range& e) {
53106       {
53107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (std::exception& e) {
53110       {
53111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53112       };
53113     } catch (Dali::DaliException e) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53116       };
53117     } catch (...) {
53118       {
53119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53120       };
53121     }
53122   }
53123
53124 }
53125
53126
53127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53128   void * jresult ;
53129   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
53130
53131   {
53132     try {
53133       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
53134     } catch (std::out_of_range& e) {
53135       {
53136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (std::exception& e) {
53139       {
53140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53141       };
53142     } catch (Dali::DaliException e) {
53143       {
53144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53145       };
53146     } catch (...) {
53147       {
53148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53149       };
53150     }
53151   }
53152
53153   jresult = (void *)result;
53154   return jresult;
53155 }
53156
53157
53158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53159   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53160
53161   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53162   {
53163     try {
53164       delete arg1;
53165     } catch (std::out_of_range& e) {
53166       {
53167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53168       };
53169     } catch (std::exception& e) {
53170       {
53171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53172       };
53173     } catch (Dali::DaliException e) {
53174       {
53175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53176       };
53177     } catch (...) {
53178       {
53179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53180       };
53181     }
53182   }
53183
53184 }
53185
53186
53187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53188   unsigned int jresult ;
53189   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53190   bool result;
53191
53192   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53193   {
53194     try {
53195       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53196     } catch (std::out_of_range& e) {
53197       {
53198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53199       };
53200     } catch (std::exception& e) {
53201       {
53202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53203       };
53204     } catch (Dali::DaliException e) {
53205       {
53206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53207       };
53208     } catch (...) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53211       };
53212     }
53213   }
53214
53215   jresult = result;
53216   return jresult;
53217 }
53218
53219
53220 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53221   unsigned long jresult ;
53222   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53223   std::size_t result;
53224
53225   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53226   {
53227     try {
53228       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53229     } catch (std::out_of_range& e) {
53230       {
53231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53232       };
53233     } catch (std::exception& e) {
53234       {
53235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53236       };
53237     } catch (Dali::DaliException e) {
53238       {
53239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53240       };
53241     } catch (...) {
53242       {
53243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53244       };
53245     }
53246   }
53247
53248   jresult = (unsigned long)result;
53249   return jresult;
53250 }
53251
53252
53253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53254   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53255   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53256
53257   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53258   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53259   {
53260     try {
53261       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53262     } catch (std::out_of_range& e) {
53263       {
53264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (std::exception& e) {
53267       {
53268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53269       };
53270     } catch (Dali::DaliException e) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53273       };
53274     } catch (...) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53277       };
53278     }
53279   }
53280
53281 }
53282
53283
53284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53285   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53286   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53287
53288   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53289   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53290   {
53291     try {
53292       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53293     } catch (std::out_of_range& e) {
53294       {
53295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53296       };
53297     } catch (std::exception& e) {
53298       {
53299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (Dali::DaliException e) {
53302       {
53303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53304       };
53305     } catch (...) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53308       };
53309     }
53310   }
53311
53312 }
53313
53314
53315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53316   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53317   Dali::WheelEvent *arg2 = 0 ;
53318
53319   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53320   arg2 = (Dali::WheelEvent *)jarg2;
53321   if (!arg2) {
53322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53323     return ;
53324   }
53325   {
53326     try {
53327       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53328     } catch (std::out_of_range& e) {
53329       {
53330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (std::exception& e) {
53333       {
53334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53335       };
53336     } catch (Dali::DaliException e) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53339       };
53340     } catch (...) {
53341       {
53342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53343       };
53344     }
53345   }
53346
53347 }
53348
53349
53350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53351   void * jresult ;
53352   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53353
53354   {
53355     try {
53356       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53357     } catch (std::out_of_range& e) {
53358       {
53359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53360       };
53361     } catch (std::exception& e) {
53362       {
53363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53364       };
53365     } catch (Dali::DaliException e) {
53366       {
53367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53368       };
53369     } catch (...) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53372       };
53373     }
53374   }
53375
53376   jresult = (void *)result;
53377   return jresult;
53378 }
53379
53380
53381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53382   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53383
53384   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53385   {
53386     try {
53387       delete arg1;
53388     } catch (std::out_of_range& e) {
53389       {
53390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53391       };
53392     } catch (std::exception& e) {
53393       {
53394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (Dali::DaliException e) {
53397       {
53398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53399       };
53400     } catch (...) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53403       };
53404     }
53405   }
53406
53407 }
53408
53409
53410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53411   void * jresult ;
53412   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53413
53414   {
53415     try {
53416       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53417     } catch (std::out_of_range& e) {
53418       {
53419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53420       };
53421     } catch (std::exception& e) {
53422       {
53423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53424       };
53425     } catch (Dali::DaliException e) {
53426       {
53427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53428       };
53429     } catch (...) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53432       };
53433     }
53434   }
53435
53436   jresult = (void *)result;
53437   return jresult;
53438 }
53439
53440
53441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53442   void * jresult ;
53443   Dali::Radian arg1 ;
53444   Dali::Radian arg2 ;
53445   Dali::Radian *argp1 ;
53446   Dali::Radian *argp2 ;
53447   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53448
53449   argp1 = (Dali::Radian *)jarg1;
53450   if (!argp1) {
53451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53452     return 0;
53453   }
53454   arg1 = *argp1;
53455   argp2 = (Dali::Radian *)jarg2;
53456   if (!argp2) {
53457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53458     return 0;
53459   }
53460   arg2 = *argp2;
53461   {
53462     try {
53463       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53464     } catch (std::out_of_range& e) {
53465       {
53466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53467       };
53468     } catch (std::exception& e) {
53469       {
53470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53471       };
53472     } catch (Dali::DaliException e) {
53473       {
53474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53475       };
53476     } catch (...) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53479       };
53480     }
53481   }
53482
53483   jresult = (void *)result;
53484   return jresult;
53485 }
53486
53487
53488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53489   void * jresult ;
53490   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53491   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53492
53493   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53494   if (!arg1) {
53495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53496     return 0;
53497   }
53498   {
53499     try {
53500       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53516       };
53517     }
53518   }
53519
53520   jresult = (void *)result;
53521   return jresult;
53522 }
53523
53524
53525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53526   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53527   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53528
53529   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53530   arg2 = (Dali::Radian *)jarg2;
53531   if (arg1) (arg1)->first = *arg2;
53532 }
53533
53534
53535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53536   void * jresult ;
53537   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53538   Dali::Radian *result = 0 ;
53539
53540   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53541   result = (Dali::Radian *)& ((arg1)->first);
53542   jresult = (void *)result;
53543   return jresult;
53544 }
53545
53546
53547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53548   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53549   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53550
53551   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53552   arg2 = (Dali::Radian *)jarg2;
53553   if (arg1) (arg1)->second = *arg2;
53554 }
53555
53556
53557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53558   void * jresult ;
53559   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53560   Dali::Radian *result = 0 ;
53561
53562   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53563   result = (Dali::Radian *)& ((arg1)->second);
53564   jresult = (void *)result;
53565   return jresult;
53566 }
53567
53568
53569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53570   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53571
53572   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53573   {
53574     try {
53575       delete arg1;
53576     } catch (std::out_of_range& e) {
53577       {
53578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53579       };
53580     } catch (std::exception& e) {
53581       {
53582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53583       };
53584     } catch (Dali::DaliException e) {
53585       {
53586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53587       };
53588     } catch (...) {
53589       {
53590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53591       };
53592     }
53593   }
53594
53595 }
53596
53597
53598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53599   unsigned int jresult ;
53600   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53601   bool result;
53602
53603   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53604   {
53605     try {
53606       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);
53607     } catch (std::out_of_range& e) {
53608       {
53609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53610       };
53611     } catch (std::exception& e) {
53612       {
53613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53614       };
53615     } catch (Dali::DaliException e) {
53616       {
53617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53618       };
53619     } catch (...) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53622       };
53623     }
53624   }
53625
53626   jresult = result;
53627   return jresult;
53628 }
53629
53630
53631 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53632   unsigned long jresult ;
53633   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53634   std::size_t result;
53635
53636   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53637   {
53638     try {
53639       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);
53640     } catch (std::out_of_range& e) {
53641       {
53642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53643       };
53644     } catch (std::exception& e) {
53645       {
53646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53647       };
53648     } catch (Dali::DaliException e) {
53649       {
53650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53651       };
53652     } catch (...) {
53653       {
53654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53655       };
53656     }
53657   }
53658
53659   jresult = (unsigned long)result;
53660   return jresult;
53661 }
53662
53663
53664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53665   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53666   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53667
53668   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53669   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53670   {
53671     try {
53672       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53673     } catch (std::out_of_range& e) {
53674       {
53675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53676       };
53677     } catch (std::exception& e) {
53678       {
53679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (Dali::DaliException e) {
53682       {
53683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53684       };
53685     } catch (...) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53688       };
53689     }
53690   }
53691
53692 }
53693
53694
53695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53696   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53697   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53698
53699   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53700   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53701   {
53702     try {
53703       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53704     } catch (std::out_of_range& e) {
53705       {
53706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53707       };
53708     } catch (std::exception& e) {
53709       {
53710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53711       };
53712     } catch (Dali::DaliException e) {
53713       {
53714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53715       };
53716     } catch (...) {
53717       {
53718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53719       };
53720     }
53721   }
53722
53723 }
53724
53725
53726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53727   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53728   Dali::Actor arg2 ;
53729   Dali::PanGesture *arg3 = 0 ;
53730   Dali::Actor *argp2 ;
53731
53732   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53733   argp2 = (Dali::Actor *)jarg2;
53734   if (!argp2) {
53735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53736     return ;
53737   }
53738   arg2 = *argp2;
53739   arg3 = (Dali::PanGesture *)jarg3;
53740   if (!arg3) {
53741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53742     return ;
53743   }
53744   {
53745     try {
53746       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53754       };
53755     } catch (Dali::DaliException e) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53762       };
53763     }
53764   }
53765
53766 }
53767
53768
53769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53770   void * jresult ;
53771   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53772
53773   {
53774     try {
53775       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53783       };
53784     } catch (Dali::DaliException e) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53787       };
53788     } catch (...) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53791       };
53792     }
53793   }
53794
53795   jresult = (void *)result;
53796   return jresult;
53797 }
53798
53799
53800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53801   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53802
53803   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53804   {
53805     try {
53806       delete arg1;
53807     } catch (std::out_of_range& e) {
53808       {
53809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53810       };
53811     } catch (std::exception& e) {
53812       {
53813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53814       };
53815     } catch (Dali::DaliException e) {
53816       {
53817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53818       };
53819     } catch (...) {
53820       {
53821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53822       };
53823     }
53824   }
53825
53826 }
53827
53828
53829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53830   unsigned int jresult ;
53831   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53832   bool result;
53833
53834   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53835   {
53836     try {
53837       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);
53838     } catch (std::out_of_range& e) {
53839       {
53840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53841       };
53842     } catch (std::exception& e) {
53843       {
53844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53845       };
53846     } catch (Dali::DaliException e) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53849       };
53850     } catch (...) {
53851       {
53852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53853       };
53854     }
53855   }
53856
53857   jresult = result;
53858   return jresult;
53859 }
53860
53861
53862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53863   unsigned long jresult ;
53864   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53865   std::size_t result;
53866
53867   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53868   {
53869     try {
53870       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);
53871     } catch (std::out_of_range& e) {
53872       {
53873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53874       };
53875     } catch (std::exception& e) {
53876       {
53877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53878       };
53879     } catch (Dali::DaliException e) {
53880       {
53881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53882       };
53883     } catch (...) {
53884       {
53885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53886       };
53887     }
53888   }
53889
53890   jresult = (unsigned long)result;
53891   return jresult;
53892 }
53893
53894
53895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53896   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53897   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53898
53899   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53900   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53901   {
53902     try {
53903       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53904     } catch (std::out_of_range& e) {
53905       {
53906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53907       };
53908     } catch (std::exception& e) {
53909       {
53910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53911       };
53912     } catch (Dali::DaliException e) {
53913       {
53914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53915       };
53916     } catch (...) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53919       };
53920     }
53921   }
53922
53923 }
53924
53925
53926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53927   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53928   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53929
53930   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53931   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53932   {
53933     try {
53934       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53935     } catch (std::out_of_range& e) {
53936       {
53937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (std::exception& e) {
53940       {
53941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (Dali::DaliException e) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53946       };
53947     } catch (...) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53950       };
53951     }
53952   }
53953
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53959   Dali::Actor arg2 ;
53960   Dali::PinchGesture *arg3 = 0 ;
53961   Dali::Actor *argp2 ;
53962
53963   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53964   argp2 = (Dali::Actor *)jarg2;
53965   if (!argp2) {
53966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53967     return ;
53968   }
53969   arg2 = *argp2;
53970   arg3 = (Dali::PinchGesture *)jarg3;
53971   if (!arg3) {
53972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53973     return ;
53974   }
53975   {
53976     try {
53977       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53978     } catch (std::out_of_range& e) {
53979       {
53980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53981       };
53982     } catch (std::exception& e) {
53983       {
53984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53985       };
53986     } catch (Dali::DaliException e) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53989       };
53990     } catch (...) {
53991       {
53992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53993       };
53994     }
53995   }
53996
53997 }
53998
53999
54000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54001   void * jresult ;
54002   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54003
54004   {
54005     try {
54006       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54007     } catch (std::out_of_range& e) {
54008       {
54009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54010       };
54011     } catch (std::exception& e) {
54012       {
54013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54014       };
54015     } catch (Dali::DaliException e) {
54016       {
54017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54018       };
54019     } catch (...) {
54020       {
54021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54022       };
54023     }
54024   }
54025
54026   jresult = (void *)result;
54027   return jresult;
54028 }
54029
54030
54031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54032   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54033
54034   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54035   {
54036     try {
54037       delete arg1;
54038     } catch (std::out_of_range& e) {
54039       {
54040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54041       };
54042     } catch (std::exception& e) {
54043       {
54044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54045       };
54046     } catch (Dali::DaliException e) {
54047       {
54048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54049       };
54050     } catch (...) {
54051       {
54052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54053       };
54054     }
54055   }
54056
54057 }
54058
54059
54060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54061   unsigned int jresult ;
54062   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54063   bool result;
54064
54065   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54066   {
54067     try {
54068       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);
54069     } catch (std::out_of_range& e) {
54070       {
54071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54072       };
54073     } catch (std::exception& e) {
54074       {
54075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54076       };
54077     } catch (Dali::DaliException e) {
54078       {
54079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54080       };
54081     } catch (...) {
54082       {
54083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54084       };
54085     }
54086   }
54087
54088   jresult = result;
54089   return jresult;
54090 }
54091
54092
54093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54094   unsigned long jresult ;
54095   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54096   std::size_t result;
54097
54098   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54099   {
54100     try {
54101       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);
54102     } catch (std::out_of_range& e) {
54103       {
54104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54105       };
54106     } catch (std::exception& e) {
54107       {
54108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54109       };
54110     } catch (Dali::DaliException e) {
54111       {
54112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54113       };
54114     } catch (...) {
54115       {
54116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54117       };
54118     }
54119   }
54120
54121   jresult = (unsigned long)result;
54122   return jresult;
54123 }
54124
54125
54126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54127   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54128   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54129
54130   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54131   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54132   {
54133     try {
54134       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54135     } catch (std::out_of_range& e) {
54136       {
54137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54138       };
54139     } catch (std::exception& e) {
54140       {
54141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54142       };
54143     } catch (Dali::DaliException e) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54146       };
54147     } catch (...) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54150       };
54151     }
54152   }
54153
54154 }
54155
54156
54157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54158   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54159   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54160
54161   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54162   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54163   {
54164     try {
54165       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54166     } catch (std::out_of_range& e) {
54167       {
54168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54169       };
54170     } catch (std::exception& e) {
54171       {
54172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54173       };
54174     } catch (Dali::DaliException e) {
54175       {
54176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54177       };
54178     } catch (...) {
54179       {
54180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54181       };
54182     }
54183   }
54184
54185 }
54186
54187
54188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54189   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54190   Dali::Actor arg2 ;
54191   Dali::TapGesture *arg3 = 0 ;
54192   Dali::Actor *argp2 ;
54193
54194   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54195   argp2 = (Dali::Actor *)jarg2;
54196   if (!argp2) {
54197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54198     return ;
54199   }
54200   arg2 = *argp2;
54201   arg3 = (Dali::TapGesture *)jarg3;
54202   if (!arg3) {
54203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54204     return ;
54205   }
54206   {
54207     try {
54208       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54209     } catch (std::out_of_range& e) {
54210       {
54211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54212       };
54213     } catch (std::exception& e) {
54214       {
54215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54216       };
54217     } catch (Dali::DaliException e) {
54218       {
54219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54220       };
54221     } catch (...) {
54222       {
54223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54224       };
54225     }
54226   }
54227
54228 }
54229
54230
54231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54232   void * jresult ;
54233   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54234
54235   {
54236     try {
54237       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54238     } catch (std::out_of_range& e) {
54239       {
54240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54241       };
54242     } catch (std::exception& e) {
54243       {
54244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54245       };
54246     } catch (Dali::DaliException e) {
54247       {
54248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54249       };
54250     } catch (...) {
54251       {
54252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54253       };
54254     }
54255   }
54256
54257   jresult = (void *)result;
54258   return jresult;
54259 }
54260
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54263   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54264
54265   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54266   {
54267     try {
54268       delete arg1;
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 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54291   unsigned int jresult ;
54292   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54293   bool result = false;
54294
54295   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54296   {
54297     try {
54298       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);
54299     } catch (std::out_of_range& e) {
54300       {
54301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54302       };
54303     } catch (std::exception& e) {
54304       {
54305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54306       };
54307     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54308   }
54309   jresult = result;
54310   return jresult;
54311 }
54312
54313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54314   unsigned long jresult ;
54315   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54316   std::size_t result = 0;
54317
54318   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54319   {
54320     try {
54321       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);
54322     } catch (std::out_of_range& e) {
54323       {
54324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (std::exception& e) {
54327       {
54328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54329       };
54330     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54331   }
54332   jresult = (unsigned long)result;
54333   return jresult;
54334 }
54335
54336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54337   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54338   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54339
54340   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54341   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54342   {
54343     try {
54344       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54345     } catch (std::out_of_range& e) {
54346       {
54347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54348       };
54349     } catch (std::exception& e) {
54350       {
54351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54352       };
54353     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54354   }
54355 }
54356
54357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54358   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54359   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54360
54361   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54362   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54363   {
54364     try {
54365       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54366     } catch (std::out_of_range& e) {
54367       {
54368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54369       };
54370     } catch (std::exception& e) {
54371       {
54372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54373       };
54374     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54375   }
54376 }
54377
54378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54379   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54380   Dali::Actor arg2 ;
54381   //bool arg3 ;
54382   Dali::LayoutDirection::Type arg4 ;
54383   Dali::Actor *argp2 ;
54384
54385   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54386   argp2 = (Dali::Actor *)jarg2;
54387   if (!argp2) {
54388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54389     return ;
54390   }
54391   arg2 = *argp2;
54392   //arg3 = jarg3 ? true : false;
54393   arg4 = (Dali::LayoutDirection::Type)jarg4;
54394   {
54395     try {
54396       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54397     } catch (std::out_of_range& e) {
54398       {
54399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54400       };
54401     } catch (std::exception& e) {
54402       {
54403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54404       };
54405     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54406   }
54407 }
54408
54409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54410   void * jresult ;
54411   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54412
54413   {
54414     try {
54415       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54416     } catch (std::out_of_range& e) {
54417       {
54418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54419       };
54420     } catch (std::exception& e) {
54421       {
54422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54423       };
54424     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54425   }
54426   jresult = (void *)result;
54427   return jresult;
54428 }
54429
54430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54431   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54432
54433   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54434   {
54435     try {
54436       delete arg1;
54437     } catch (std::out_of_range& e) {
54438       {
54439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54440       };
54441     } catch (std::exception& e) {
54442       {
54443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54446   }
54447 }
54448
54449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54450   unsigned int jresult ;
54451   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54452   bool result;
54453
54454   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54455   {
54456     try {
54457       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);
54458     } catch (std::out_of_range& e) {
54459       {
54460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54461       };
54462     } catch (std::exception& e) {
54463       {
54464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54465       };
54466     } catch (Dali::DaliException e) {
54467       {
54468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54469       };
54470     } catch (...) {
54471       {
54472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54473       };
54474     }
54475   }
54476
54477   jresult = result;
54478   return jresult;
54479 }
54480
54481
54482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54483   unsigned long jresult ;
54484   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54485   std::size_t result;
54486
54487   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54488   {
54489     try {
54490       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);
54491     } catch (std::out_of_range& e) {
54492       {
54493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54494       };
54495     } catch (std::exception& e) {
54496       {
54497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54498       };
54499     } catch (Dali::DaliException e) {
54500       {
54501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54502       };
54503     } catch (...) {
54504       {
54505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54506       };
54507     }
54508   }
54509
54510   jresult = (unsigned long)result;
54511   return jresult;
54512 }
54513
54514
54515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54516   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54517   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54518
54519   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54520   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54521   {
54522     try {
54523       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54524     } catch (std::out_of_range& e) {
54525       {
54526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54527       };
54528     } catch (std::exception& e) {
54529       {
54530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54531       };
54532     } catch (Dali::DaliException e) {
54533       {
54534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54535       };
54536     } catch (...) {
54537       {
54538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54539       };
54540     }
54541   }
54542
54543 }
54544
54545
54546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54547   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54548   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54549
54550   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54551   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54552   {
54553     try {
54554       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54555     } catch (std::out_of_range& e) {
54556       {
54557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54558       };
54559     } catch (std::exception& e) {
54560       {
54561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54562       };
54563     } catch (Dali::DaliException e) {
54564       {
54565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54566       };
54567     } catch (...) {
54568       {
54569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54570       };
54571     }
54572   }
54573
54574 }
54575
54576
54577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54578   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54579   Dali::Actor arg2 ;
54580   bool arg3 ;
54581   Dali::DevelActor::VisibilityChange::Type arg4 ;
54582   Dali::Actor *argp2 ;
54583
54584   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54585   argp2 = (Dali::Actor *)jarg2;
54586   if (!argp2) {
54587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54588     return ;
54589   }
54590   arg2 = *argp2;
54591   arg3 = jarg3 ? true : false;
54592   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54593   {
54594     try {
54595       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54596     } catch (std::out_of_range& e) {
54597       {
54598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54599       };
54600     } catch (std::exception& e) {
54601       {
54602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54603       };
54604     } catch (Dali::DaliException e) {
54605       {
54606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54607       };
54608     } catch (...) {
54609       {
54610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54611       };
54612     }
54613   }
54614
54615 }
54616
54617
54618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54619   void * jresult ;
54620   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54621
54622   {
54623     try {
54624       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54625     } catch (std::out_of_range& e) {
54626       {
54627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54628       };
54629     } catch (std::exception& e) {
54630       {
54631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54632       };
54633     } catch (Dali::DaliException e) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54636       };
54637     } catch (...) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54640       };
54641     }
54642   }
54643
54644   jresult = (void *)result;
54645   return jresult;
54646 }
54647
54648
54649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54650   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54651
54652   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54653   {
54654     try {
54655       delete arg1;
54656     } catch (std::out_of_range& e) {
54657       {
54658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54659       };
54660     } catch (std::exception& e) {
54661       {
54662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54663       };
54664     } catch (Dali::DaliException e) {
54665       {
54666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54667       };
54668     } catch (...) {
54669       {
54670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54671       };
54672     }
54673   }
54674
54675 }
54676
54677
54678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54679   void * jresult ;
54680   Dali::Timer *result = 0 ;
54681
54682   {
54683     try {
54684       result = (Dali::Timer *)new Dali::Timer();
54685     } catch (std::out_of_range& e) {
54686       {
54687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54688       };
54689     } catch (std::exception& e) {
54690       {
54691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54692       };
54693     } catch (Dali::DaliException e) {
54694       {
54695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54696       };
54697     } catch (...) {
54698       {
54699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54700       };
54701     }
54702   }
54703
54704   jresult = (void *)result;
54705   return jresult;
54706 }
54707
54708
54709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54710   void * jresult ;
54711   unsigned int arg1 ;
54712   Dali::Timer result;
54713
54714   arg1 = (unsigned int)jarg1;
54715   {
54716     try {
54717       result = Dali::Timer::New(arg1);
54718     } catch (std::out_of_range& e) {
54719       {
54720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54721       };
54722     } catch (std::exception& e) {
54723       {
54724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54725       };
54726     } catch (Dali::DaliException e) {
54727       {
54728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54729       };
54730     } catch (...) {
54731       {
54732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54733       };
54734     }
54735   }
54736
54737   jresult = new Dali::Timer((const Dali::Timer &)result);
54738   return jresult;
54739 }
54740
54741
54742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54743   void * jresult ;
54744   Dali::Timer *arg1 = 0 ;
54745   Dali::Timer *result = 0 ;
54746
54747   arg1 = (Dali::Timer *)jarg1;
54748   if (!arg1) {
54749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54750     return 0;
54751   }
54752   {
54753     try {
54754       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54755     } catch (std::out_of_range& e) {
54756       {
54757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (std::exception& e) {
54760       {
54761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (Dali::DaliException e) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54766       };
54767     } catch (...) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54770       };
54771     }
54772   }
54773
54774   jresult = (void *)result;
54775   return jresult;
54776 }
54777
54778
54779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54780   void * jresult ;
54781   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54782   Dali::Timer *arg2 = 0 ;
54783   Dali::Timer *result = 0 ;
54784
54785   arg1 = (Dali::Timer *)jarg1;
54786   arg2 = (Dali::Timer *)jarg2;
54787   if (!arg2) {
54788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54789     return 0;
54790   }
54791   {
54792     try {
54793       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54794     } catch (std::out_of_range& e) {
54795       {
54796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54797       };
54798     } catch (std::exception& e) {
54799       {
54800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54801       };
54802     } catch (Dali::DaliException e) {
54803       {
54804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54805       };
54806     } catch (...) {
54807       {
54808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54809       };
54810     }
54811   }
54812
54813   jresult = (void *)result;
54814   return jresult;
54815 }
54816
54817
54818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54819   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54820
54821   arg1 = (Dali::Timer *)jarg1;
54822   {
54823     try {
54824       delete arg1;
54825     } catch (std::out_of_range& e) {
54826       {
54827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54828       };
54829     } catch (std::exception& e) {
54830       {
54831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54832       };
54833     } catch (Dali::DaliException e) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54836       };
54837     } catch (...) {
54838       {
54839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54840       };
54841     }
54842   }
54843
54844 }
54845
54846
54847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54848   void * jresult ;
54849   Dali::BaseHandle arg1 ;
54850   Dali::BaseHandle *argp1 ;
54851   Dali::Timer result;
54852
54853   argp1 = (Dali::BaseHandle *)jarg1;
54854   if (!argp1) {
54855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54856     return 0;
54857   }
54858   arg1 = *argp1;
54859   {
54860     try {
54861       result = Dali::Timer::DownCast(arg1);
54862     } catch (std::out_of_range& e) {
54863       {
54864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54865       };
54866     } catch (std::exception& e) {
54867       {
54868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54869       };
54870     } catch (Dali::DaliException e) {
54871       {
54872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54873       };
54874     } catch (...) {
54875       {
54876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54877       };
54878     }
54879   }
54880
54881   jresult = new Dali::Timer((const Dali::Timer &)result);
54882   return jresult;
54883 }
54884
54885
54886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54887   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54888
54889   arg1 = (Dali::Timer *)jarg1;
54890   {
54891     try {
54892       (arg1)->Start();
54893     } catch (std::out_of_range& e) {
54894       {
54895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54896       };
54897     } catch (std::exception& e) {
54898       {
54899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54900       };
54901     } catch (Dali::DaliException e) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54904       };
54905     } catch (...) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54908       };
54909     }
54910   }
54911
54912 }
54913
54914
54915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54916   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54917
54918   arg1 = (Dali::Timer *)jarg1;
54919   {
54920     try {
54921       (arg1)->Stop();
54922     } catch (std::out_of_range& e) {
54923       {
54924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54925       };
54926     } catch (std::exception& e) {
54927       {
54928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54929       };
54930     } catch (Dali::DaliException e) {
54931       {
54932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54937       };
54938     }
54939   }
54940
54941 }
54942
54943
54944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54945   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54946   unsigned int arg2 ;
54947
54948   arg1 = (Dali::Timer *)jarg1;
54949   arg2 = (unsigned int)jarg2;
54950   {
54951     try {
54952       (arg1)->SetInterval(arg2);
54953     } catch (std::out_of_range& e) {
54954       {
54955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54956       };
54957     } catch (std::exception& e) {
54958       {
54959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54960       };
54961     } catch (Dali::DaliException e) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54964       };
54965     } catch (...) {
54966       {
54967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54968       };
54969     }
54970   }
54971
54972 }
54973
54974
54975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54976   unsigned int jresult ;
54977   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54978   unsigned int result;
54979
54980   arg1 = (Dali::Timer *)jarg1;
54981   {
54982     try {
54983       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54984     } catch (std::out_of_range& e) {
54985       {
54986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54987       };
54988     } catch (std::exception& e) {
54989       {
54990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54991       };
54992     } catch (Dali::DaliException e) {
54993       {
54994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54995       };
54996     } catch (...) {
54997       {
54998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54999       };
55000     }
55001   }
55002
55003   jresult = result;
55004   return jresult;
55005 }
55006
55007
55008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55009   unsigned int jresult ;
55010   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55011   bool result;
55012
55013   arg1 = (Dali::Timer *)jarg1;
55014   {
55015     try {
55016       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55017     } catch (std::out_of_range& e) {
55018       {
55019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55020       };
55021     } catch (std::exception& e) {
55022       {
55023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55024       };
55025     } catch (Dali::DaliException e) {
55026       {
55027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55028       };
55029     } catch (...) {
55030       {
55031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55032       };
55033     }
55034   }
55035
55036   jresult = result;
55037   return jresult;
55038 }
55039
55040
55041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55042   void * jresult ;
55043   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55044   Dali::Timer::TimerSignalType *result = 0 ;
55045
55046   arg1 = (Dali::Timer *)jarg1;
55047   {
55048     try {
55049       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55050     } catch (std::out_of_range& e) {
55051       {
55052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55053       };
55054     } catch (std::exception& e) {
55055       {
55056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55057       };
55058     } catch (Dali::DaliException e) {
55059       {
55060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55061       };
55062     } catch (...) {
55063       {
55064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55065       };
55066     }
55067   }
55068
55069   jresult = (void *)result;
55070   return jresult;
55071 }
55072
55073
55074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55075   unsigned int jresult ;
55076   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55077   bool result;
55078
55079   arg1 = (Dali::Signal< bool () > *)jarg1;
55080   {
55081     try {
55082       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55083     } catch (std::out_of_range& e) {
55084       {
55085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55086       };
55087     } catch (std::exception& e) {
55088       {
55089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (Dali::DaliException e) {
55092       {
55093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101
55102   jresult = result;
55103   return jresult;
55104 }
55105
55106
55107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55108   unsigned long jresult ;
55109   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55110   std::size_t result;
55111
55112   arg1 = (Dali::Signal< bool () > *)jarg1;
55113   {
55114     try {
55115       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55116     } catch (std::out_of_range& e) {
55117       {
55118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55119       };
55120     } catch (std::exception& e) {
55121       {
55122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55123       };
55124     } catch (Dali::DaliException e) {
55125       {
55126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55127       };
55128     } catch (...) {
55129       {
55130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55131       };
55132     }
55133   }
55134
55135   jresult = (unsigned long)result;
55136   return jresult;
55137 }
55138
55139
55140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55141   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55142   bool (*arg2)() = (bool (*)()) 0 ;
55143
55144   arg1 = (Dali::Signal< bool () > *)jarg1;
55145   arg2 = (bool (*)())jarg2;
55146   {
55147     try {
55148       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55149     } catch (std::out_of_range& e) {
55150       {
55151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55152       };
55153     } catch (std::exception& e) {
55154       {
55155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55156       };
55157     } catch (Dali::DaliException e) {
55158       {
55159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55160       };
55161     } catch (...) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55164       };
55165     }
55166   }
55167
55168 }
55169
55170
55171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55172   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55173   bool (*arg2)() = (bool (*)()) 0 ;
55174
55175   arg1 = (Dali::Signal< bool () > *)jarg1;
55176   arg2 = (bool (*)())jarg2;
55177   {
55178     try {
55179       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55187       };
55188     } catch (Dali::DaliException e) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55191       };
55192     } catch (...) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55195       };
55196     }
55197   }
55198
55199 }
55200
55201
55202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55203   unsigned int jresult ;
55204   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55205   bool result;
55206
55207   arg1 = (Dali::Signal< bool () > *)jarg1;
55208   {
55209     try {
55210       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55218       };
55219     } catch (Dali::DaliException e) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55222       };
55223     } catch (...) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55226       };
55227     }
55228   }
55229
55230   jresult = result;
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55236   void * jresult ;
55237   Dali::Signal< bool () > *result = 0 ;
55238
55239   {
55240     try {
55241       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55242     } catch (std::out_of_range& e) {
55243       {
55244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55245       };
55246     } catch (std::exception& e) {
55247       {
55248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55249       };
55250     } catch (Dali::DaliException e) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55253       };
55254     } catch (...) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55257       };
55258     }
55259   }
55260
55261   jresult = (void *)result;
55262   return jresult;
55263 }
55264
55265
55266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55267   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55268
55269   arg1 = (Dali::Signal< bool () > *)jarg1;
55270   {
55271     try {
55272       delete arg1;
55273     } catch (std::out_of_range& e) {
55274       {
55275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55276       };
55277     } catch (std::exception& e) {
55278       {
55279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55280       };
55281     } catch (Dali::DaliException e) {
55282       {
55283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55284       };
55285     } catch (...) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55288       };
55289     }
55290   }
55291
55292 }
55293
55294
55295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55296   int jresult ;
55297   int result;
55298
55299   {
55300     try {
55301       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55302     } catch (std::out_of_range& e) {
55303       {
55304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55305       };
55306     } catch (std::exception& e) {
55307       {
55308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55309       };
55310     } catch (Dali::DaliException e) {
55311       {
55312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55313       };
55314     } catch (...) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55317       };
55318     }
55319   }
55320
55321   jresult = (int)result;
55322   return jresult;
55323 }
55324
55325
55326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55327   int jresult ;
55328   int result;
55329
55330   {
55331     try {
55332       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55333     } catch (std::out_of_range& e) {
55334       {
55335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55336       };
55337     } catch (std::exception& e) {
55338       {
55339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55340       };
55341     } catch (Dali::DaliException e) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55344       };
55345     } catch (...) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55348       };
55349     }
55350   }
55351
55352   jresult = (int)result;
55353   return jresult;
55354 }
55355
55356
55357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55358   int jresult ;
55359   int result;
55360
55361   {
55362     try {
55363       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55364     } catch (std::out_of_range& e) {
55365       {
55366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55367       };
55368     } catch (std::exception& e) {
55369       {
55370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55371       };
55372     } catch (Dali::DaliException e) {
55373       {
55374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55375       };
55376     } catch (...) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55379       };
55380     }
55381   }
55382
55383   jresult = (int)result;
55384   return jresult;
55385 }
55386
55387
55388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55389   int jresult ;
55390   int result;
55391
55392   {
55393     try {
55394       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55395     } catch (std::out_of_range& e) {
55396       {
55397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55398       };
55399     } catch (std::exception& e) {
55400       {
55401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55402       };
55403     } catch (Dali::DaliException e) {
55404       {
55405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55406       };
55407     } catch (...) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55410       };
55411     }
55412   }
55413
55414   jresult = (int)result;
55415   return jresult;
55416 }
55417
55418
55419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55420   int jresult ;
55421   int result;
55422
55423   {
55424     try {
55425       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55426     } catch (std::out_of_range& e) {
55427       {
55428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55429       };
55430     } catch (std::exception& e) {
55431       {
55432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55433       };
55434     } catch (Dali::DaliException e) {
55435       {
55436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55437       };
55438     } catch (...) {
55439       {
55440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55441       };
55442     }
55443   }
55444
55445   jresult = (int)result;
55446   return jresult;
55447 }
55448
55449
55450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55451   int jresult ;
55452   int result;
55453
55454   {
55455     try {
55456       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55457     } catch (std::out_of_range& e) {
55458       {
55459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55460       };
55461     } catch (std::exception& e) {
55462       {
55463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55464       };
55465     } catch (Dali::DaliException e) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55468       };
55469     } catch (...) {
55470       {
55471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55472       };
55473     }
55474   }
55475
55476   jresult = (int)result;
55477   return jresult;
55478 }
55479
55480
55481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55482   int jresult ;
55483   int result;
55484
55485   {
55486     try {
55487       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55488     } catch (std::out_of_range& e) {
55489       {
55490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55491       };
55492     } catch (std::exception& e) {
55493       {
55494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55495       };
55496     } catch (Dali::DaliException e) {
55497       {
55498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55499       };
55500     } catch (...) {
55501       {
55502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55503       };
55504     }
55505   }
55506
55507   jresult = (int)result;
55508   return jresult;
55509 }
55510
55511
55512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55513   int jresult ;
55514   int result;
55515
55516   {
55517     try {
55518       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55519     } catch (std::out_of_range& e) {
55520       {
55521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55522       };
55523     } catch (std::exception& e) {
55524       {
55525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55526       };
55527     } catch (Dali::DaliException e) {
55528       {
55529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55530       };
55531     } catch (...) {
55532       {
55533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55534       };
55535     }
55536   }
55537
55538   jresult = (int)result;
55539   return jresult;
55540 }
55541
55542
55543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55544   int jresult ;
55545   int result;
55546
55547   {
55548     try {
55549       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55550     } catch (std::out_of_range& e) {
55551       {
55552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55553       };
55554     } catch (std::exception& e) {
55555       {
55556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55557       };
55558     } catch (Dali::DaliException e) {
55559       {
55560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55561       };
55562     } catch (...) {
55563       {
55564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55565       };
55566     }
55567   }
55568
55569   jresult = (int)result;
55570   return jresult;
55571 }
55572
55573
55574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55575   int jresult ;
55576   int result;
55577
55578   {
55579     try {
55580       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55581     } catch (std::out_of_range& e) {
55582       {
55583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (std::exception& e) {
55586       {
55587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (Dali::DaliException e) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55592       };
55593     } catch (...) {
55594       {
55595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55596       };
55597     }
55598   }
55599
55600   jresult = (int)result;
55601   return jresult;
55602 }
55603
55604
55605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55606   int jresult ;
55607   int result;
55608
55609   {
55610     try {
55611       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55612     } catch (std::out_of_range& e) {
55613       {
55614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55615       };
55616     } catch (std::exception& e) {
55617       {
55618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55619       };
55620     } catch (Dali::DaliException e) {
55621       {
55622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55623       };
55624     } catch (...) {
55625       {
55626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55627       };
55628     }
55629   }
55630
55631   jresult = (int)result;
55632   return jresult;
55633 }
55634
55635
55636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55637   int jresult ;
55638   int result;
55639
55640   {
55641     try {
55642       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55643     } catch (std::out_of_range& e) {
55644       {
55645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55646       };
55647     } catch (std::exception& e) {
55648       {
55649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55650       };
55651     } catch (Dali::DaliException e) {
55652       {
55653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55654       };
55655     } catch (...) {
55656       {
55657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55658       };
55659     }
55660   }
55661
55662   jresult = (int)result;
55663   return jresult;
55664 }
55665
55666
55667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55668   int jresult ;
55669   int result;
55670
55671   {
55672     try {
55673       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55674     } catch (std::out_of_range& e) {
55675       {
55676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55677       };
55678     } catch (std::exception& e) {
55679       {
55680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55681       };
55682     } catch (Dali::DaliException e) {
55683       {
55684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55685       };
55686     } catch (...) {
55687       {
55688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55689       };
55690     }
55691   }
55692
55693   jresult = (int)result;
55694   return jresult;
55695 }
55696
55697
55698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55699   int jresult ;
55700   int result;
55701
55702   {
55703     try {
55704       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55705     } catch (std::out_of_range& e) {
55706       {
55707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55708       };
55709     } catch (std::exception& e) {
55710       {
55711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (Dali::DaliException e) {
55714       {
55715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55720       };
55721     }
55722   }
55723
55724   jresult = (int)result;
55725   return jresult;
55726 }
55727
55728
55729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55730   int jresult ;
55731   int result;
55732
55733   {
55734     try {
55735       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (Dali::DaliException e) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55751       };
55752     }
55753   }
55754
55755   jresult = (int)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55761   int jresult ;
55762   int result;
55763
55764   {
55765     try {
55766       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (Dali::DaliException e) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55778       };
55779     } catch (...) {
55780       {
55781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55782       };
55783     }
55784   }
55785
55786   jresult = (int)result;
55787   return jresult;
55788 }
55789
55790
55791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55792   int jresult ;
55793   int result;
55794
55795   {
55796     try {
55797       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55798     } catch (std::out_of_range& e) {
55799       {
55800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55801       };
55802     } catch (std::exception& e) {
55803       {
55804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55805       };
55806     } catch (Dali::DaliException e) {
55807       {
55808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55809       };
55810     } catch (...) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55813       };
55814     }
55815   }
55816
55817   jresult = (int)result;
55818   return jresult;
55819 }
55820
55821
55822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55823   int jresult ;
55824   int result;
55825
55826   {
55827     try {
55828       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55829     } catch (std::out_of_range& e) {
55830       {
55831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55832       };
55833     } catch (std::exception& e) {
55834       {
55835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55836       };
55837     } catch (Dali::DaliException e) {
55838       {
55839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55840       };
55841     } catch (...) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55844       };
55845     }
55846   }
55847
55848   jresult = (int)result;
55849   return jresult;
55850 }
55851
55852
55853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55854   int jresult ;
55855   int result;
55856
55857   {
55858     try {
55859       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55867       };
55868     } catch (Dali::DaliException e) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55871       };
55872     } catch (...) {
55873       {
55874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55875       };
55876     }
55877   }
55878
55879   jresult = (int)result;
55880   return jresult;
55881 }
55882
55883
55884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55885   int jresult ;
55886   int result;
55887
55888   {
55889     try {
55890       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55891     } catch (std::out_of_range& e) {
55892       {
55893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55894       };
55895     } catch (std::exception& e) {
55896       {
55897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55898       };
55899     } catch (Dali::DaliException e) {
55900       {
55901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55902       };
55903     } catch (...) {
55904       {
55905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55906       };
55907     }
55908   }
55909
55910   jresult = (int)result;
55911   return jresult;
55912 }
55913
55914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55915   int jresult ;
55916   int result;
55917
55918   {
55919     try {
55920       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55921     } catch (std::out_of_range& e) {
55922       {
55923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55924       };
55925     } catch (std::exception& e) {
55926       {
55927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55928       };
55929     } catch (Dali::DaliException e) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55932       };
55933     } catch (...) {
55934       {
55935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55936       };
55937     }
55938   }
55939
55940   jresult = (int)result;
55941   return jresult;
55942 }
55943
55944
55945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55946   int jresult ;
55947   int result;
55948   {
55949     try
55950     {
55951       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55952     } catch (std::out_of_range& e) {
55953       {
55954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55955       };
55956     } catch (std::exception& e) {
55957       {
55958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55959       };
55960     } catch (Dali::DaliException e) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55963       };
55964     } catch (...) {
55965       {
55966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55967       };
55968     }
55969   }
55970
55971   jresult = (int)result;
55972   return jresult;
55973 }
55974
55975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55976   int jresult ;
55977   int result;
55978   {
55979     try
55980     {
55981       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55982     } catch (std::out_of_range& e) {
55983       {
55984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55985       };
55986     } catch (std::exception& e) {
55987       {
55988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55989       };
55990     } catch (Dali::DaliException e) {
55991       {
55992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55993       };
55994     } catch (...) {
55995       {
55996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55997       };
55998     }
55999   }
56000
56001   jresult = (int)result;
56002   return jresult;
56003 }
56004
56005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56006   int jresult ;
56007   int result;
56008   {
56009     try
56010     {
56011       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56012     } catch (std::out_of_range& e) {
56013       {
56014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56015       };
56016     } catch (std::exception& e) {
56017       {
56018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56019       };
56020     } catch (Dali::DaliException e) {
56021       {
56022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56023       };
56024     } catch (...) {
56025       {
56026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56027       };
56028     }
56029   }
56030
56031   jresult = (int)result;
56032   return jresult;
56033 }
56034
56035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56036   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56037 }
56038
56039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56040   int jresult ;
56041   int result;
56042   {
56043     try
56044     {
56045       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56046     } catch (std::out_of_range& e) {
56047       {
56048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56049       };
56050     } catch (std::exception& e) {
56051       {
56052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56053       };
56054     } catch (Dali::DaliException e) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56057       };
56058     } catch (...) {
56059       {
56060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56061       };
56062     }
56063   }
56064
56065   jresult = (int)result;
56066   return jresult;
56067 }
56068
56069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56070   int jresult ;
56071   int result;
56072   {
56073     try
56074     {
56075       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56076     } catch (std::out_of_range& e) {
56077       {
56078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56079       };
56080     } catch (std::exception& e) {
56081       {
56082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (Dali::DaliException e) {
56085       {
56086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56087       };
56088     } catch (...) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56091       };
56092     }
56093   }
56094
56095   jresult = (int)result;
56096   return jresult;
56097 }
56098
56099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56100   int jresult ;
56101   int result;
56102
56103   {
56104     try {
56105       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56106     } catch (std::out_of_range& e) {
56107       {
56108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56109       };
56110     } catch (std::exception& e) {
56111       {
56112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56113       };
56114     } catch (Dali::DaliException e) {
56115       {
56116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56117       };
56118     } catch (...) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56121       };
56122     }
56123   }
56124
56125   jresult = (int)result;
56126   return jresult;
56127 }
56128
56129
56130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56131   int jresult ;
56132   int result;
56133
56134   {
56135     try {
56136       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56137     } catch (std::out_of_range& e) {
56138       {
56139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (std::exception& e) {
56142       {
56143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56144       };
56145     } catch (Dali::DaliException e) {
56146       {
56147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56148       };
56149     } catch (...) {
56150       {
56151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56152       };
56153     }
56154   }
56155
56156   jresult = (int)result;
56157   return jresult;
56158 }
56159
56160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56161   int jresult ;
56162   int result;
56163   {
56164     try
56165     {
56166       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56167     } catch (std::out_of_range& e) {
56168       {
56169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56170       };
56171     } catch (std::exception& e) {
56172       {
56173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56174       };
56175     } catch (...) {
56176       {
56177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56178       };
56179     }
56180   }
56181   jresult = (int)result;
56182   return jresult;
56183 }
56184
56185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56186   int jresult ;
56187   int result;
56188   {
56189     try
56190     {
56191       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56192     } catch (std::out_of_range& e) {
56193       {
56194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56195       };
56196     } catch (std::exception& e) {
56197       {
56198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56199       };
56200     } catch (...) {
56201       {
56202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56203       };
56204     }
56205   }
56206   jresult = (int)result;
56207   return jresult;
56208 }
56209
56210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56211   int jresult ;
56212   int result;
56213   {
56214     try
56215     {
56216       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56217     } catch (std::out_of_range& e) {
56218       {
56219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56220       };
56221     } catch (std::exception& e) {
56222       {
56223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (...) {
56226       {
56227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56228       };
56229     }
56230   }
56231   jresult = (int)result;
56232   return jresult;
56233 }
56234
56235
56236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56237   int jresult ;
56238   int result;
56239   {
56240     try
56241     {
56242       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56243     } catch (std::out_of_range& e) {
56244       {
56245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56246       };
56247     } catch (std::exception& e) {
56248       {
56249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (...) {
56252       {
56253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56254       };
56255     }
56256   }
56257   jresult = (int)result;
56258   return jresult;
56259 }
56260
56261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56262   int jresult ;
56263   int result;
56264   {
56265     try
56266     {
56267       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56268     } catch (std::out_of_range& e) {
56269       {
56270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56271       };
56272     } catch (std::exception& e) {
56273       {
56274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56275       };
56276     } catch (...) {
56277       {
56278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56279       };
56280     }
56281   }
56282   jresult = (int)result;
56283   return jresult;
56284 }
56285
56286
56287
56288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56289   int jresult ;
56290   int result;
56291
56292   {
56293     try {
56294       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56295     } catch (std::out_of_range& e) {
56296       {
56297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56298       };
56299     } catch (std::exception& e) {
56300       {
56301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56302       };
56303     } catch (Dali::DaliException e) {
56304       {
56305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56306       };
56307     } catch (...) {
56308       {
56309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56310       };
56311     }
56312   }
56313
56314   jresult = (int)result;
56315   return jresult;
56316 }
56317
56318
56319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56320   int jresult ;
56321   int result;
56322
56323   {
56324     try {
56325       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56326     } catch (std::out_of_range& e) {
56327       {
56328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56329       };
56330     } catch (std::exception& e) {
56331       {
56332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56333       };
56334     } catch (Dali::DaliException e) {
56335       {
56336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56337       };
56338     } catch (...) {
56339       {
56340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56341       };
56342     }
56343   }
56344
56345   jresult = (int)result;
56346   return jresult;
56347 }
56348
56349
56350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56351   int jresult ;
56352   int result;
56353
56354   {
56355     try {
56356       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56357     } catch (std::out_of_range& e) {
56358       {
56359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56360       };
56361     } catch (std::exception& e) {
56362       {
56363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (Dali::DaliException e) {
56366       {
56367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56368       };
56369     } catch (...) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56372       };
56373     }
56374   }
56375
56376   jresult = (int)result;
56377   return jresult;
56378 }
56379
56380
56381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56382   int jresult ;
56383   int result;
56384
56385   {
56386     try {
56387       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56388     } catch (std::out_of_range& e) {
56389       {
56390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56391       };
56392     } catch (std::exception& e) {
56393       {
56394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56395       };
56396     } catch (Dali::DaliException e) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56399       };
56400     } catch (...) {
56401       {
56402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56403       };
56404     }
56405   }
56406
56407   jresult = (int)result;
56408   return jresult;
56409 }
56410
56411
56412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56413   int jresult ;
56414   int result;
56415
56416   {
56417     try {
56418       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (Dali::DaliException e) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56434       };
56435     }
56436   }
56437
56438   jresult = (int)result;
56439   return jresult;
56440 }
56441
56442
56443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56444   int jresult ;
56445   int result;
56446
56447   {
56448     try {
56449       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56450     } catch (std::out_of_range& e) {
56451       {
56452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56453       };
56454     } catch (std::exception& e) {
56455       {
56456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (Dali::DaliException e) {
56459       {
56460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56461       };
56462     } catch (...) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56465       };
56466     }
56467   }
56468
56469   jresult = (int)result;
56470   return jresult;
56471 }
56472
56473
56474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56475   int jresult ;
56476   int result;
56477
56478   {
56479     try {
56480       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56481     } catch (std::out_of_range& e) {
56482       {
56483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56484       };
56485     } catch (std::exception& e) {
56486       {
56487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56488       };
56489     } catch (Dali::DaliException e) {
56490       {
56491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56492       };
56493     } catch (...) {
56494       {
56495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56496       };
56497     }
56498   }
56499
56500   jresult = (int)result;
56501   return jresult;
56502 }
56503
56504 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56505   int jresult ;
56506   int result;
56507
56508   {
56509     try {
56510       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56511     } catch (std::out_of_range& e) {
56512       {
56513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56514       };
56515     } catch (std::exception& e) {
56516       {
56517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56518       };
56519     } catch (...) {
56520       {
56521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56522       };
56523     }
56524   }
56525   jresult = (int)result;
56526   return jresult;
56527 }
56528
56529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56530   int jresult ;
56531   int result;
56532
56533   {
56534     try {
56535       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56536     } catch (std::out_of_range& e) {
56537       {
56538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56539       };
56540     } catch (std::exception& e) {
56541       {
56542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56543       };
56544     } catch (Dali::DaliException e) {
56545       {
56546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56547       };
56548     } catch (...) {
56549       {
56550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56551       };
56552     }
56553   }
56554
56555   jresult = (int)result;
56556   return jresult;
56557 }
56558
56559
56560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56561   int jresult ;
56562   int result;
56563
56564   {
56565     try {
56566       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56567     } catch (std::out_of_range& e) {
56568       {
56569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56570       };
56571     } catch (std::exception& e) {
56572       {
56573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56574       };
56575     } catch (Dali::DaliException e) {
56576       {
56577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56578       };
56579     } catch (...) {
56580       {
56581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56582       };
56583     }
56584   }
56585
56586   jresult = (int)result;
56587   return jresult;
56588 }
56589
56590
56591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56592   int jresult ;
56593   int result;
56594
56595   {
56596     try {
56597       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56598     } catch (std::out_of_range& e) {
56599       {
56600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56601       };
56602     } catch (std::exception& e) {
56603       {
56604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56605       };
56606     } catch (Dali::DaliException e) {
56607       {
56608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56609       };
56610     } catch (...) {
56611       {
56612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56613       };
56614     }
56615   }
56616
56617   jresult = (int)result;
56618   return jresult;
56619 }
56620
56621
56622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56623   int jresult ;
56624   int result;
56625
56626   {
56627     try {
56628       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56629     } catch (std::out_of_range& e) {
56630       {
56631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56632       };
56633     } catch (std::exception& e) {
56634       {
56635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56636       };
56637     } catch (Dali::DaliException e) {
56638       {
56639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56640       };
56641     } catch (...) {
56642       {
56643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56644       };
56645     }
56646   }
56647
56648   jresult = (int)result;
56649   return jresult;
56650 }
56651
56652
56653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56654   int jresult ;
56655   int result;
56656
56657   {
56658     try {
56659       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56660     } catch (std::out_of_range& e) {
56661       {
56662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56663       };
56664     } catch (std::exception& e) {
56665       {
56666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56667       };
56668     } catch (Dali::DaliException e) {
56669       {
56670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56671       };
56672     } catch (...) {
56673       {
56674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56675       };
56676     }
56677   }
56678
56679   jresult = (int)result;
56680   return jresult;
56681 }
56682
56683
56684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56685   int jresult ;
56686   int result;
56687
56688   {
56689     try {
56690       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56691     } catch (std::out_of_range& e) {
56692       {
56693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56694       };
56695     } catch (std::exception& e) {
56696       {
56697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56698       };
56699     } catch (Dali::DaliException e) {
56700       {
56701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56702       };
56703     } catch (...) {
56704       {
56705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56706       };
56707     }
56708   }
56709
56710   jresult = (int)result;
56711   return jresult;
56712 }
56713
56714
56715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56716   int jresult ;
56717   int result;
56718
56719   {
56720     try {
56721       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56722     } catch (std::out_of_range& e) {
56723       {
56724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (std::exception& e) {
56727       {
56728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56729       };
56730     } catch (Dali::DaliException e) {
56731       {
56732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56733       };
56734     } catch (...) {
56735       {
56736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56737       };
56738     }
56739   }
56740
56741   jresult = (int)result;
56742   return jresult;
56743 }
56744
56745
56746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56747   int jresult ;
56748   int result;
56749
56750   {
56751     try {
56752       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56753     } catch (std::out_of_range& e) {
56754       {
56755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56756       };
56757     } catch (std::exception& e) {
56758       {
56759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (Dali::DaliException e) {
56762       {
56763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56764       };
56765     } catch (...) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56768       };
56769     }
56770   }
56771
56772   jresult = (int)result;
56773   return jresult;
56774 }
56775
56776
56777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56778   int jresult ;
56779   int result;
56780
56781   {
56782     try {
56783       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56784     } catch (std::out_of_range& e) {
56785       {
56786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56787       };
56788     } catch (std::exception& e) {
56789       {
56790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56791       };
56792     } catch (Dali::DaliException e) {
56793       {
56794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56795       };
56796     } catch (...) {
56797       {
56798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56799       };
56800     }
56801   }
56802
56803   jresult = (int)result;
56804   return jresult;
56805 }
56806
56807
56808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56809   int jresult ;
56810   int result;
56811
56812   {
56813     try {
56814       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56815     } catch (std::out_of_range& e) {
56816       {
56817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56818       };
56819     } catch (std::exception& e) {
56820       {
56821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56822       };
56823     } catch (Dali::DaliException e) {
56824       {
56825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56826       };
56827     } catch (...) {
56828       {
56829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56830       };
56831     }
56832   }
56833
56834   jresult = (int)result;
56835   return jresult;
56836 }
56837
56838
56839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56840   int jresult ;
56841   int result;
56842
56843   {
56844     try {
56845       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56846     } catch (std::out_of_range& e) {
56847       {
56848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56849       };
56850     } catch (std::exception& e) {
56851       {
56852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56853       };
56854     } catch (Dali::DaliException e) {
56855       {
56856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56857       };
56858     } catch (...) {
56859       {
56860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56861       };
56862     }
56863   }
56864
56865   jresult = (int)result;
56866   return jresult;
56867 }
56868
56869
56870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56871   int jresult ;
56872   int result;
56873
56874   {
56875     try {
56876       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56877     } catch (std::out_of_range& e) {
56878       {
56879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56880       };
56881     } catch (std::exception& e) {
56882       {
56883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56884       };
56885     } catch (Dali::DaliException e) {
56886       {
56887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56888       };
56889     } catch (...) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56892       };
56893     }
56894   }
56895
56896   jresult = (int)result;
56897   return jresult;
56898 }
56899
56900
56901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56902   int jresult ;
56903   int result;
56904
56905   {
56906     try {
56907       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56908     } catch (std::out_of_range& e) {
56909       {
56910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56911       };
56912     } catch (std::exception& e) {
56913       {
56914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56915       };
56916     } catch (Dali::DaliException e) {
56917       {
56918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56919       };
56920     } catch (...) {
56921       {
56922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56923       };
56924     }
56925   }
56926
56927   jresult = (int)result;
56928   return jresult;
56929 }
56930
56931
56932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56933   int jresult ;
56934   int result;
56935
56936   {
56937     try {
56938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56939     } catch (std::out_of_range& e) {
56940       {
56941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56942       };
56943     } catch (std::exception& e) {
56944       {
56945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56946       };
56947     } catch (Dali::DaliException e) {
56948       {
56949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56950       };
56951     } catch (...) {
56952       {
56953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56954       };
56955     }
56956   }
56957
56958   jresult = (int)result;
56959   return jresult;
56960 }
56961
56962
56963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56964   int jresult ;
56965   int result;
56966
56967   {
56968     try {
56969       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56970     } catch (std::out_of_range& e) {
56971       {
56972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56973       };
56974     } catch (std::exception& e) {
56975       {
56976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56977       };
56978     } catch (Dali::DaliException e) {
56979       {
56980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56981       };
56982     } catch (...) {
56983       {
56984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56985       };
56986     }
56987   }
56988
56989   jresult = (int)result;
56990   return jresult;
56991 }
56992
56993
56994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56995   int jresult ;
56996   int result;
56997
56998   {
56999     try {
57000       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (Dali::DaliException e) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019
57020   jresult = (int)result;
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57026   int jresult ;
57027   int result;
57028
57029   {
57030     try {
57031       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57032     } catch (std::out_of_range& e) {
57033       {
57034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57035       };
57036     } catch (std::exception& e) {
57037       {
57038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57039       };
57040     } catch (Dali::DaliException e) {
57041       {
57042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57043       };
57044     } catch (...) {
57045       {
57046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57047       };
57048     }
57049   }
57050
57051   jresult = (int)result;
57052   return jresult;
57053 }
57054
57055
57056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57057   int jresult ;
57058   int result;
57059
57060   {
57061     try {
57062       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57063     } catch (std::out_of_range& e) {
57064       {
57065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57066       };
57067     } catch (std::exception& e) {
57068       {
57069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (Dali::DaliException e) {
57072       {
57073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57074       };
57075     } catch (...) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57078       };
57079     }
57080   }
57081
57082   jresult = (int)result;
57083   return jresult;
57084 }
57085
57086
57087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57088   int jresult ;
57089   int result;
57090
57091   {
57092     try {
57093       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57094     } catch (std::out_of_range& e) {
57095       {
57096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57097       };
57098     } catch (std::exception& e) {
57099       {
57100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57101       };
57102     } catch (Dali::DaliException e) {
57103       {
57104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57105       };
57106     } catch (...) {
57107       {
57108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57109       };
57110     }
57111   }
57112
57113   jresult = (int)result;
57114   return jresult;
57115 }
57116
57117
57118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57119   int jresult ;
57120   int result;
57121
57122   {
57123     try {
57124       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57125     } catch (std::out_of_range& e) {
57126       {
57127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57128       };
57129     } catch (std::exception& e) {
57130       {
57131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57132       };
57133     } catch (Dali::DaliException e) {
57134       {
57135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57136       };
57137     } catch (...) {
57138       {
57139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57140       };
57141     }
57142   }
57143
57144   jresult = (int)result;
57145   return jresult;
57146 }
57147
57148
57149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57150   int jresult ;
57151   int result;
57152
57153   {
57154     try {
57155       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57156     } catch (std::out_of_range& e) {
57157       {
57158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57159       };
57160     } catch (std::exception& e) {
57161       {
57162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57163       };
57164     } catch (Dali::DaliException e) {
57165       {
57166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57167       };
57168     } catch (...) {
57169       {
57170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57171       };
57172     }
57173   }
57174
57175   jresult = (int)result;
57176   return jresult;
57177 }
57178
57179
57180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57181   int jresult ;
57182   int result;
57183
57184   {
57185     try {
57186       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57187     } catch (std::out_of_range& e) {
57188       {
57189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57190       };
57191     } catch (std::exception& e) {
57192       {
57193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57194       };
57195     } catch (Dali::DaliException e) {
57196       {
57197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57198       };
57199     } catch (...) {
57200       {
57201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57202       };
57203     }
57204   }
57205
57206   jresult = (int)result;
57207   return jresult;
57208 }
57209
57210
57211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57212   int jresult ;
57213   int result;
57214
57215   {
57216     try {
57217       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57218     } catch (std::out_of_range& e) {
57219       {
57220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57221       };
57222     } catch (std::exception& e) {
57223       {
57224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (Dali::DaliException e) {
57227       {
57228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57229       };
57230     } catch (...) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57233       };
57234     }
57235   }
57236
57237   jresult = (int)result;
57238   return jresult;
57239 }
57240
57241
57242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57243   int jresult ;
57244   int result;
57245
57246   {
57247     try {
57248       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57249     } catch (std::out_of_range& e) {
57250       {
57251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57252       };
57253     } catch (std::exception& e) {
57254       {
57255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57256       };
57257     } catch (Dali::DaliException e) {
57258       {
57259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57260       };
57261     } catch (...) {
57262       {
57263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57264       };
57265     }
57266   }
57267
57268   jresult = (int)result;
57269   return jresult;
57270 }
57271
57272
57273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57274   int jresult ;
57275   int result;
57276
57277   {
57278     try {
57279       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57280     } catch (std::out_of_range& e) {
57281       {
57282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57283       };
57284     } catch (std::exception& e) {
57285       {
57286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57287       };
57288     } catch (Dali::DaliException e) {
57289       {
57290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57291       };
57292     } catch (...) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57295       };
57296     }
57297   }
57298
57299   jresult = (int)result;
57300   return jresult;
57301 }
57302
57303
57304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57305   int jresult ;
57306   int result;
57307
57308   {
57309     try {
57310       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57311     } catch (std::out_of_range& e) {
57312       {
57313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57314       };
57315     } catch (std::exception& e) {
57316       {
57317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57318       };
57319     } catch (Dali::DaliException e) {
57320       {
57321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57322       };
57323     } catch (...) {
57324       {
57325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57326       };
57327     }
57328   }
57329
57330   jresult = (int)result;
57331   return jresult;
57332 }
57333
57334
57335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57336   int jresult ;
57337   int result;
57338
57339   {
57340     try {
57341       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57342     } catch (std::out_of_range& e) {
57343       {
57344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57345       };
57346     } catch (std::exception& e) {
57347       {
57348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57349       };
57350     } catch (Dali::DaliException e) {
57351       {
57352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57353       };
57354     } catch (...) {
57355       {
57356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57357       };
57358     }
57359   }
57360
57361   jresult = (int)result;
57362   return jresult;
57363 }
57364
57365
57366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57367   int jresult ;
57368   int result;
57369
57370   {
57371     try {
57372       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57373     } catch (std::out_of_range& e) {
57374       {
57375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57376       };
57377     } catch (std::exception& e) {
57378       {
57379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57380       };
57381     } catch (Dali::DaliException e) {
57382       {
57383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57384       };
57385     } catch (...) {
57386       {
57387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57388       };
57389     }
57390   }
57391
57392   jresult = (int)result;
57393   return jresult;
57394 }
57395
57396
57397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57398   void * jresult ;
57399   Dali::Toolkit::Builder *result = 0 ;
57400
57401   {
57402     try {
57403       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57404     } catch (std::out_of_range& e) {
57405       {
57406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57407       };
57408     } catch (std::exception& e) {
57409       {
57410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (Dali::DaliException e) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57415       };
57416     } catch (...) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57419       };
57420     }
57421   }
57422
57423   jresult = (void *)result;
57424   return jresult;
57425 }
57426
57427
57428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57429   void * jresult ;
57430   Dali::Toolkit::Builder result;
57431
57432   {
57433     try {
57434       result = Dali::Toolkit::Builder::New();
57435     } catch (std::out_of_range& e) {
57436       {
57437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57438       };
57439     } catch (std::exception& e) {
57440       {
57441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57442       };
57443     } catch (Dali::DaliException e) {
57444       {
57445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57446       };
57447     } catch (...) {
57448       {
57449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57450       };
57451     }
57452   }
57453
57454   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57455   return jresult;
57456 }
57457
57458
57459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57460   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57461
57462   arg1 = (Dali::Toolkit::Builder *)jarg1;
57463   {
57464     try {
57465       delete arg1;
57466     } catch (std::out_of_range& e) {
57467       {
57468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57469       };
57470     } catch (std::exception& e) {
57471       {
57472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57473       };
57474     } catch (Dali::DaliException e) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57481       };
57482     }
57483   }
57484
57485 }
57486
57487
57488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57489   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57490   std::string *arg2 = 0 ;
57491   Dali::Toolkit::Builder::UIFormat arg3 ;
57492
57493   arg1 = (Dali::Toolkit::Builder *)jarg1;
57494   if (!jarg2) {
57495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57496     return ;
57497   }
57498   std::string arg2_str(jarg2);
57499   arg2 = &arg2_str;
57500   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57501   {
57502     try {
57503       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57504     } catch (std::out_of_range& e) {
57505       {
57506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57507       };
57508     } catch (std::exception& e) {
57509       {
57510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57511       };
57512     } catch (Dali::DaliException e) {
57513       {
57514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57515       };
57516     } catch (...) {
57517       {
57518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57519       };
57520     }
57521   }
57522
57523
57524   //argout typemap for const std::string&
57525
57526 }
57527
57528
57529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57531   std::string *arg2 = 0 ;
57532
57533   arg1 = (Dali::Toolkit::Builder *)jarg1;
57534   if (!jarg2) {
57535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57536     return ;
57537   }
57538   std::string arg2_str(jarg2);
57539   arg2 = &arg2_str;
57540   {
57541     try {
57542       (arg1)->LoadFromString((std::string const &)*arg2);
57543     } catch (std::out_of_range& e) {
57544       {
57545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57546       };
57547     } catch (std::exception& e) {
57548       {
57549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57550       };
57551     } catch (Dali::DaliException e) {
57552       {
57553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57554       };
57555     } catch (...) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57558       };
57559     }
57560   }
57561
57562
57563   //argout typemap for const std::string&
57564
57565 }
57566
57567
57568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57569   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57570   Dali::Property::Map *arg2 = 0 ;
57571
57572   arg1 = (Dali::Toolkit::Builder *)jarg1;
57573   arg2 = (Dali::Property::Map *)jarg2;
57574   if (!arg2) {
57575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57576     return ;
57577   }
57578   {
57579     try {
57580       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57588       };
57589     } catch (Dali::DaliException e) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57596       };
57597     }
57598   }
57599
57600 }
57601
57602
57603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57605   std::string *arg2 = 0 ;
57606   Dali::Property::Value *arg3 = 0 ;
57607
57608   arg1 = (Dali::Toolkit::Builder *)jarg1;
57609   if (!jarg2) {
57610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57611     return ;
57612   }
57613   std::string arg2_str(jarg2);
57614   arg2 = &arg2_str;
57615   arg3 = (Dali::Property::Value *)jarg3;
57616   if (!arg3) {
57617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57618     return ;
57619   }
57620   {
57621     try {
57622       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57623     } catch (std::out_of_range& e) {
57624       {
57625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57626       };
57627     } catch (std::exception& e) {
57628       {
57629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57630       };
57631     } catch (Dali::DaliException e) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57638       };
57639     }
57640   }
57641
57642
57643   //argout typemap for const std::string&
57644
57645 }
57646
57647
57648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57649   void * jresult ;
57650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57651   Dali::Property::Map *result = 0 ;
57652
57653   arg1 = (Dali::Toolkit::Builder *)jarg1;
57654   {
57655     try {
57656       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57657     } catch (std::out_of_range& e) {
57658       {
57659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57660       };
57661     } catch (std::exception& e) {
57662       {
57663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57664       };
57665     } catch (Dali::DaliException e) {
57666       {
57667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57668       };
57669     } catch (...) {
57670       {
57671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57672       };
57673     }
57674   }
57675
57676   jresult = (void *)result;
57677   return jresult;
57678 }
57679
57680
57681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57682   void * jresult ;
57683   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57684   std::string *arg2 = 0 ;
57685   Dali::Property::Value *result = 0 ;
57686
57687   arg1 = (Dali::Toolkit::Builder *)jarg1;
57688   if (!jarg2) {
57689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57690     return 0;
57691   }
57692   std::string arg2_str(jarg2);
57693   arg2 = &arg2_str;
57694   {
57695     try {
57696       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57697     } catch (std::out_of_range& e) {
57698       {
57699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57700       };
57701     } catch (std::exception& e) {
57702       {
57703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57704       };
57705     } catch (Dali::DaliException e) {
57706       {
57707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57708       };
57709     } catch (...) {
57710       {
57711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57712       };
57713     }
57714   }
57715
57716   jresult = (void *)result;
57717
57718   //argout typemap for const std::string&
57719
57720   return jresult;
57721 }
57722
57723
57724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57725   void * jresult ;
57726   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57727   std::string *arg2 = 0 ;
57728   Dali::Animation result;
57729
57730   arg1 = (Dali::Toolkit::Builder *)jarg1;
57731   if (!jarg2) {
57732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57733     return 0;
57734   }
57735   std::string arg2_str(jarg2);
57736   arg2 = &arg2_str;
57737   {
57738     try {
57739       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57740     } catch (std::out_of_range& e) {
57741       {
57742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57743       };
57744     } catch (std::exception& e) {
57745       {
57746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57747       };
57748     } catch (Dali::DaliException e) {
57749       {
57750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57751       };
57752     } catch (...) {
57753       {
57754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57755       };
57756     }
57757   }
57758
57759   jresult = new Dali::Animation((const Dali::Animation &)result);
57760
57761   //argout typemap for const std::string&
57762
57763   return jresult;
57764 }
57765
57766
57767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57768   void * jresult ;
57769   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57770   std::string *arg2 = 0 ;
57771   Dali::Property::Map *arg3 = 0 ;
57772   Dali::Animation result;
57773
57774   arg1 = (Dali::Toolkit::Builder *)jarg1;
57775   if (!jarg2) {
57776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57777     return 0;
57778   }
57779   std::string arg2_str(jarg2);
57780   arg2 = &arg2_str;
57781   arg3 = (Dali::Property::Map *)jarg3;
57782   if (!arg3) {
57783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57784     return 0;
57785   }
57786   {
57787     try {
57788       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57789     } catch (std::out_of_range& e) {
57790       {
57791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57792       };
57793     } catch (std::exception& e) {
57794       {
57795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57796       };
57797     } catch (Dali::DaliException e) {
57798       {
57799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57800       };
57801     } catch (...) {
57802       {
57803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57804       };
57805     }
57806   }
57807
57808   jresult = new Dali::Animation((const Dali::Animation &)result);
57809
57810   //argout typemap for const std::string&
57811
57812   return jresult;
57813 }
57814
57815
57816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57817   void * jresult ;
57818   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57819   std::string *arg2 = 0 ;
57820   Dali::Actor arg3 ;
57821   Dali::Actor *argp3 ;
57822   Dali::Animation result;
57823
57824   arg1 = (Dali::Toolkit::Builder *)jarg1;
57825   if (!jarg2) {
57826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57827     return 0;
57828   }
57829   std::string arg2_str(jarg2);
57830   arg2 = &arg2_str;
57831   argp3 = (Dali::Actor *)jarg3;
57832   if (!argp3) {
57833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57834     return 0;
57835   }
57836   arg3 = *argp3;
57837   {
57838     try {
57839       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57840     } catch (std::out_of_range& e) {
57841       {
57842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (std::exception& e) {
57845       {
57846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57847       };
57848     } catch (Dali::DaliException e) {
57849       {
57850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57851       };
57852     } catch (...) {
57853       {
57854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57855       };
57856     }
57857   }
57858
57859   jresult = new Dali::Animation((const Dali::Animation &)result);
57860
57861   //argout typemap for const std::string&
57862
57863   return jresult;
57864 }
57865
57866
57867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57868   void * jresult ;
57869   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57870   std::string *arg2 = 0 ;
57871   Dali::Property::Map *arg3 = 0 ;
57872   Dali::Actor arg4 ;
57873   Dali::Actor *argp4 ;
57874   Dali::Animation result;
57875
57876   arg1 = (Dali::Toolkit::Builder *)jarg1;
57877   if (!jarg2) {
57878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57879     return 0;
57880   }
57881   std::string arg2_str(jarg2);
57882   arg2 = &arg2_str;
57883   arg3 = (Dali::Property::Map *)jarg3;
57884   if (!arg3) {
57885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57886     return 0;
57887   }
57888   argp4 = (Dali::Actor *)jarg4;
57889   if (!argp4) {
57890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57891     return 0;
57892   }
57893   arg4 = *argp4;
57894   {
57895     try {
57896       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57897     } catch (std::out_of_range& e) {
57898       {
57899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57900       };
57901     } catch (std::exception& e) {
57902       {
57903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57904       };
57905     } catch (Dali::DaliException e) {
57906       {
57907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57908       };
57909     } catch (...) {
57910       {
57911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57912       };
57913     }
57914   }
57915
57916   jresult = new Dali::Animation((const Dali::Animation &)result);
57917
57918   //argout typemap for const std::string&
57919
57920   return jresult;
57921 }
57922
57923
57924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57925   void * jresult ;
57926   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57927   std::string *arg2 = 0 ;
57928   Dali::BaseHandle result;
57929
57930   arg1 = (Dali::Toolkit::Builder *)jarg1;
57931   if (!jarg2) {
57932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57933     return 0;
57934   }
57935   std::string arg2_str(jarg2);
57936   arg2 = &arg2_str;
57937   {
57938     try {
57939       result = (arg1)->Create((std::string const &)*arg2);
57940     } catch (std::out_of_range& e) {
57941       {
57942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57943       };
57944     } catch (std::exception& e) {
57945       {
57946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57947       };
57948     } catch (Dali::DaliException e) {
57949       {
57950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57951       };
57952     } catch (...) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57955       };
57956     }
57957   }
57958
57959   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57960
57961   //argout typemap for const std::string&
57962
57963   return jresult;
57964 }
57965
57966
57967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57968   void * jresult ;
57969   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57970   std::string *arg2 = 0 ;
57971   Dali::Property::Map *arg3 = 0 ;
57972   Dali::BaseHandle result;
57973
57974   arg1 = (Dali::Toolkit::Builder *)jarg1;
57975   if (!jarg2) {
57976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57977     return 0;
57978   }
57979   std::string arg2_str(jarg2);
57980   arg2 = &arg2_str;
57981   arg3 = (Dali::Property::Map *)jarg3;
57982   if (!arg3) {
57983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57984     return 0;
57985   }
57986   {
57987     try {
57988       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57989     } catch (std::out_of_range& e) {
57990       {
57991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57992       };
57993     } catch (std::exception& e) {
57994       {
57995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57996       };
57997     } catch (Dali::DaliException e) {
57998       {
57999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58000       };
58001     } catch (...) {
58002       {
58003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58004       };
58005     }
58006   }
58007
58008   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58009
58010   //argout typemap for const std::string&
58011
58012   return jresult;
58013 }
58014
58015
58016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58017   void * jresult ;
58018   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58019   std::string *arg2 = 0 ;
58020   Dali::BaseHandle result;
58021
58022   arg1 = (Dali::Toolkit::Builder *)jarg1;
58023   if (!jarg2) {
58024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58025     return 0;
58026   }
58027   std::string arg2_str(jarg2);
58028   arg2 = &arg2_str;
58029   {
58030     try {
58031       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58032     } catch (std::out_of_range& e) {
58033       {
58034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58035       };
58036     } catch (std::exception& e) {
58037       {
58038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58039       };
58040     } catch (Dali::DaliException e) {
58041       {
58042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58043       };
58044     } catch (...) {
58045       {
58046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58047       };
58048     }
58049   }
58050
58051   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58052
58053   //argout typemap for const std::string&
58054
58055   return jresult;
58056 }
58057
58058
58059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58060   unsigned int jresult ;
58061   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58062   std::string *arg2 = 0 ;
58063   Dali::Handle *arg3 = 0 ;
58064   bool result;
58065
58066   arg1 = (Dali::Toolkit::Builder *)jarg1;
58067   if (!jarg2) {
58068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58069     return 0;
58070   }
58071   std::string arg2_str(jarg2);
58072   arg2 = &arg2_str;
58073   arg3 = (Dali::Handle *)jarg3;
58074   if (!arg3) {
58075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58076     return 0;
58077   }
58078   {
58079     try {
58080       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58081     } catch (std::out_of_range& e) {
58082       {
58083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58084       };
58085     } catch (std::exception& e) {
58086       {
58087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58088       };
58089     } catch (Dali::DaliException e) {
58090       {
58091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58092       };
58093     } catch (...) {
58094       {
58095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58096       };
58097     }
58098   }
58099
58100   jresult = result;
58101
58102   //argout typemap for const std::string&
58103
58104   return jresult;
58105 }
58106
58107
58108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58109   unsigned int jresult ;
58110   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58111   Dali::Handle *arg2 = 0 ;
58112   std::string *arg3 = 0 ;
58113   bool result;
58114
58115   arg1 = (Dali::Toolkit::Builder *)jarg1;
58116   arg2 = (Dali::Handle *)jarg2;
58117   if (!arg2) {
58118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58119     return 0;
58120   }
58121   if (!jarg3) {
58122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58123     return 0;
58124   }
58125   std::string arg3_str(jarg3);
58126   arg3 = &arg3_str;
58127   {
58128     try {
58129       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58130     } catch (std::out_of_range& e) {
58131       {
58132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58133       };
58134     } catch (std::exception& e) {
58135       {
58136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58137       };
58138     } catch (Dali::DaliException e) {
58139       {
58140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58141       };
58142     } catch (...) {
58143       {
58144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58145       };
58146     }
58147   }
58148
58149   jresult = result;
58150
58151   //argout typemap for const std::string&
58152
58153   return jresult;
58154 }
58155
58156
58157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58158   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58159   Dali::Actor arg2 ;
58160   Dali::Actor *argp2 ;
58161
58162   arg1 = (Dali::Toolkit::Builder *)jarg1;
58163   argp2 = (Dali::Actor *)jarg2;
58164   if (!argp2) {
58165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58166     return ;
58167   }
58168   arg2 = *argp2;
58169   {
58170     try {
58171       (arg1)->AddActors(arg2);
58172     } catch (std::out_of_range& e) {
58173       {
58174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58175       };
58176     } catch (std::exception& e) {
58177       {
58178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58179       };
58180     } catch (Dali::DaliException e) {
58181       {
58182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58183       };
58184     } catch (...) {
58185       {
58186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58187       };
58188     }
58189   }
58190
58191 }
58192
58193
58194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58195   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58196   std::string *arg2 = 0 ;
58197   Dali::Actor arg3 ;
58198   Dali::Actor *argp3 ;
58199
58200   arg1 = (Dali::Toolkit::Builder *)jarg1;
58201   if (!jarg2) {
58202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58203     return ;
58204   }
58205   std::string arg2_str(jarg2);
58206   arg2 = &arg2_str;
58207   argp3 = (Dali::Actor *)jarg3;
58208   if (!argp3) {
58209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58210     return ;
58211   }
58212   arg3 = *argp3;
58213   {
58214     try {
58215       (arg1)->AddActors((std::string const &)*arg2,arg3);
58216     } catch (std::out_of_range& e) {
58217       {
58218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58219       };
58220     } catch (std::exception& e) {
58221       {
58222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58223       };
58224     } catch (Dali::DaliException e) {
58225       {
58226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58227       };
58228     } catch (...) {
58229       {
58230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58231       };
58232     }
58233   }
58234
58235
58236   //argout typemap for const std::string&
58237
58238 }
58239
58240
58241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58242   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58243   std::string *arg2 = 0 ;
58244
58245   arg1 = (Dali::Toolkit::Builder *)jarg1;
58246   if (!jarg2) {
58247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58248     return ;
58249   }
58250   std::string arg2_str(jarg2);
58251   arg2 = &arg2_str;
58252   {
58253     try {
58254       (arg1)->CreateRenderTask((std::string const &)*arg2);
58255     } catch (std::out_of_range& e) {
58256       {
58257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58258       };
58259     } catch (std::exception& e) {
58260       {
58261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58262       };
58263     } catch (Dali::DaliException e) {
58264       {
58265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58266       };
58267     } catch (...) {
58268       {
58269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58270       };
58271     }
58272   }
58273
58274
58275   //argout typemap for const std::string&
58276
58277 }
58278
58279
58280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58281   void * jresult ;
58282   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58283   std::string *arg2 = 0 ;
58284   Dali::Path result;
58285
58286   arg1 = (Dali::Toolkit::Builder *)jarg1;
58287   if (!jarg2) {
58288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58289     return 0;
58290   }
58291   std::string arg2_str(jarg2);
58292   arg2 = &arg2_str;
58293   {
58294     try {
58295       result = (arg1)->GetPath((std::string const &)*arg2);
58296     } catch (std::out_of_range& e) {
58297       {
58298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58299       };
58300     } catch (std::exception& e) {
58301       {
58302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (Dali::DaliException e) {
58305       {
58306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58307       };
58308     } catch (...) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58311       };
58312     }
58313   }
58314
58315   jresult = new Dali::Path((const Dali::Path &)result);
58316
58317   //argout typemap for const std::string&
58318
58319   return jresult;
58320 }
58321
58322
58323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58324   void * jresult ;
58325   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58326   std::string *arg2 = 0 ;
58327   Dali::PathConstrainer result;
58328
58329   arg1 = (Dali::Toolkit::Builder *)jarg1;
58330   if (!jarg2) {
58331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58332     return 0;
58333   }
58334   std::string arg2_str(jarg2);
58335   arg2 = &arg2_str;
58336   {
58337     try {
58338       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58339     } catch (std::out_of_range& e) {
58340       {
58341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58342       };
58343     } catch (std::exception& e) {
58344       {
58345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (Dali::DaliException e) {
58348       {
58349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58350       };
58351     } catch (...) {
58352       {
58353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58354       };
58355     }
58356   }
58357
58358   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58359
58360   //argout typemap for const std::string&
58361
58362   return jresult;
58363 }
58364
58365
58366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58367   void * jresult ;
58368   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58369   std::string *arg2 = 0 ;
58370   Dali::LinearConstrainer result;
58371
58372   arg1 = (Dali::Toolkit::Builder *)jarg1;
58373   if (!jarg2) {
58374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58375     return 0;
58376   }
58377   std::string arg2_str(jarg2);
58378   arg2 = &arg2_str;
58379   {
58380     try {
58381       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58382     } catch (std::out_of_range& e) {
58383       {
58384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (std::exception& e) {
58387       {
58388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (Dali::DaliException e) {
58391       {
58392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58393       };
58394     } catch (...) {
58395       {
58396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58397       };
58398     }
58399   }
58400
58401   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58402
58403   //argout typemap for const std::string&
58404
58405   return jresult;
58406 }
58407
58408
58409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58410   void * jresult ;
58411   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58412   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58413
58414   arg1 = (Dali::Toolkit::Builder *)jarg1;
58415   {
58416     try {
58417       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58418     } catch (std::out_of_range& e) {
58419       {
58420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58421       };
58422     } catch (std::exception& e) {
58423       {
58424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58425       };
58426     } catch (Dali::DaliException e) {
58427       {
58428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58429       };
58430     } catch (...) {
58431       {
58432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58433       };
58434     }
58435   }
58436
58437   jresult = (void *)result;
58438   return jresult;
58439 }
58440
58441
58442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58443   void * jresult ;
58444   Dali::Toolkit::TransitionData *result = 0 ;
58445
58446   {
58447     try {
58448       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58449     } catch (std::out_of_range& e) {
58450       {
58451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58452       };
58453     } catch (std::exception& e) {
58454       {
58455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58456       };
58457     } catch (Dali::DaliException e) {
58458       {
58459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58460       };
58461     } catch (...) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58464       };
58465     }
58466   }
58467
58468   jresult = (void *)result;
58469   return jresult;
58470 }
58471
58472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58473   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58474
58475   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58476   {
58477     try {
58478       delete arg1;
58479     } catch (std::out_of_range& e) {
58480       {
58481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58482       };
58483     } catch (std::exception& e) {
58484       {
58485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58486       };
58487     } catch (Dali::DaliException e) {
58488       {
58489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58490       };
58491     } catch (...) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58494       };
58495     }
58496   }
58497
58498 }
58499
58500
58501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58502   void * jresult ;
58503   Dali::Property::Map *arg1 = 0 ;
58504   Dali::Toolkit::TransitionData result;
58505
58506   arg1 = (Dali::Property::Map *)jarg1;
58507   if (!arg1) {
58508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58509     return 0;
58510   }
58511   {
58512     try {
58513       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58514     } catch (std::out_of_range& e) {
58515       {
58516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58517       };
58518     } catch (std::exception& e) {
58519       {
58520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58521       };
58522     } catch (Dali::DaliException e) {
58523       {
58524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58525       };
58526     } catch (...) {
58527       {
58528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58529       };
58530     }
58531   }
58532
58533   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58534   return jresult;
58535 }
58536
58537
58538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58539   void * jresult ;
58540   Dali::Property::Array *arg1 = 0 ;
58541   Dali::Toolkit::TransitionData result;
58542
58543   arg1 = (Dali::Property::Array *)jarg1;
58544   if (!arg1) {
58545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58546     return 0;
58547   }
58548   {
58549     try {
58550       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
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 = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58571   return jresult;
58572 }
58573
58574
58575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58576   void * jresult ;
58577   Dali::BaseHandle arg1 ;
58578   Dali::BaseHandle *argp1 ;
58579   Dali::Toolkit::TransitionData result;
58580
58581   argp1 = (Dali::BaseHandle *)jarg1;
58582   if (!argp1) {
58583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58584     return 0;
58585   }
58586   arg1 = *argp1;
58587   {
58588     try {
58589       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58590     } catch (std::out_of_range& e) {
58591       {
58592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58593       };
58594     } catch (std::exception& e) {
58595       {
58596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58597       };
58598     } catch (Dali::DaliException e) {
58599       {
58600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58601       };
58602     } catch (...) {
58603       {
58604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58605       };
58606     }
58607   }
58608
58609   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58610   return jresult;
58611 }
58612
58613
58614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58615   void * jresult ;
58616   Dali::Toolkit::TransitionData *arg1 = 0 ;
58617   Dali::Toolkit::TransitionData *result = 0 ;
58618
58619   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58620   if (!arg1) {
58621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58622     return 0;
58623   }
58624   {
58625     try {
58626       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58627     } catch (std::out_of_range& e) {
58628       {
58629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58630       };
58631     } catch (std::exception& e) {
58632       {
58633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58634       };
58635     } catch (Dali::DaliException e) {
58636       {
58637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58638       };
58639     } catch (...) {
58640       {
58641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58642       };
58643     }
58644   }
58645
58646   jresult = (void *)result;
58647   return jresult;
58648 }
58649
58650
58651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58652   void * jresult ;
58653   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58654   Dali::Toolkit::TransitionData *arg2 = 0 ;
58655   Dali::Toolkit::TransitionData *result = 0 ;
58656
58657   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58658   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58659   if (!arg2) {
58660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58661     return 0;
58662   }
58663   {
58664     try {
58665       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58666     } catch (std::out_of_range& e) {
58667       {
58668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58669       };
58670     } catch (std::exception& e) {
58671       {
58672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58673       };
58674     } catch (Dali::DaliException e) {
58675       {
58676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58677       };
58678     } catch (...) {
58679       {
58680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58681       };
58682     }
58683   }
58684
58685   jresult = (void *)result;
58686   return jresult;
58687 }
58688
58689
58690 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58691   unsigned long jresult ;
58692   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58693   size_t result;
58694
58695   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58696   {
58697     try {
58698       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58699     } catch (std::out_of_range& e) {
58700       {
58701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (std::exception& e) {
58704       {
58705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58706       };
58707     } catch (Dali::DaliException e) {
58708       {
58709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58710       };
58711     } catch (...) {
58712       {
58713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58714       };
58715     }
58716   }
58717
58718   jresult = (unsigned long)result;
58719   return jresult;
58720 }
58721
58722
58723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58724   void * jresult ;
58725   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58726   size_t arg2 ;
58727   Dali::Property::Map result;
58728
58729   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58730   arg2 = (size_t)jarg2;
58731   {
58732     try {
58733       result = (arg1)->GetAnimatorAt(arg2);
58734     } catch (std::out_of_range& e) {
58735       {
58736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58737       };
58738     } catch (std::exception& e) {
58739       {
58740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58741       };
58742     } catch (Dali::DaliException e) {
58743       {
58744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58745       };
58746     } catch (...) {
58747       {
58748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58749       };
58750     }
58751   }
58752
58753   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58754   return jresult;
58755 }
58756
58757
58758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58759   int jresult ;
58760   int result;
58761
58762   {
58763     try {
58764       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58765     } catch (std::out_of_range& e) {
58766       {
58767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58768       };
58769     } catch (std::exception& e) {
58770       {
58771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (Dali::DaliException e) {
58774       {
58775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58776       };
58777     } catch (...) {
58778       {
58779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58780       };
58781     }
58782   }
58783
58784   jresult = (int)result;
58785   return jresult;
58786 }
58787
58788
58789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58790   int jresult ;
58791   int result;
58792
58793   {
58794     try {
58795       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58796     } catch (std::out_of_range& e) {
58797       {
58798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58799       };
58800     } catch (std::exception& e) {
58801       {
58802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58803       };
58804     } catch (Dali::DaliException e) {
58805       {
58806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58807       };
58808     } catch (...) {
58809       {
58810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58811       };
58812     }
58813   }
58814
58815   jresult = (int)result;
58816   return jresult;
58817 }
58818
58819
58820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58821   int jresult ;
58822   int result;
58823
58824   {
58825     try {
58826       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58827     } catch (std::out_of_range& e) {
58828       {
58829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58830       };
58831     } catch (std::exception& e) {
58832       {
58833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58834       };
58835     } catch (Dali::DaliException e) {
58836       {
58837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58838       };
58839     } catch (...) {
58840       {
58841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58842       };
58843     }
58844   }
58845
58846   jresult = (int)result;
58847   return jresult;
58848 }
58849
58850
58851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58852   int jresult ;
58853   int result;
58854
58855   {
58856     try {
58857       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58858     } catch (std::out_of_range& e) {
58859       {
58860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58861       };
58862     } catch (std::exception& e) {
58863       {
58864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58865       };
58866     } catch (Dali::DaliException e) {
58867       {
58868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58869       };
58870     } catch (...) {
58871       {
58872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58873       };
58874     }
58875   }
58876
58877   jresult = (int)result;
58878   return jresult;
58879 }
58880
58881
58882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58883   int jresult ;
58884   int result;
58885
58886   {
58887     try {
58888       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58889     } catch (std::out_of_range& e) {
58890       {
58891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58892       };
58893     } catch (std::exception& e) {
58894       {
58895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58896       };
58897     } catch (Dali::DaliException e) {
58898       {
58899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58900       };
58901     } catch (...) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58904       };
58905     }
58906   }
58907
58908   jresult = (int)result;
58909   return jresult;
58910 }
58911
58912
58913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58914   int jresult ;
58915   int result;
58916
58917   {
58918     try {
58919       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58920     } catch (std::out_of_range& e) {
58921       {
58922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (std::exception& e) {
58925       {
58926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58927       };
58928     } catch (Dali::DaliException e) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58931       };
58932     } catch (...) {
58933       {
58934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58935       };
58936     }
58937   }
58938
58939   jresult = (int)result;
58940   return jresult;
58941 }
58942
58943
58944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58945   int jresult ;
58946   int result;
58947
58948   {
58949     try {
58950       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58951     } catch (std::out_of_range& e) {
58952       {
58953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58954       };
58955     } catch (std::exception& e) {
58956       {
58957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (Dali::DaliException e) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58962       };
58963     } catch (...) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58966       };
58967     }
58968   }
58969
58970   jresult = (int)result;
58971   return jresult;
58972 }
58973
58974
58975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58976   int jresult ;
58977   int result;
58978
58979   {
58980     try {
58981       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58982     } catch (std::out_of_range& e) {
58983       {
58984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58985       };
58986     } catch (std::exception& e) {
58987       {
58988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58989       };
58990     } catch (Dali::DaliException e) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58993       };
58994     } catch (...) {
58995       {
58996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58997       };
58998     }
58999   }
59000
59001   jresult = (int)result;
59002   return jresult;
59003 }
59004
59005
59006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59007   int jresult ;
59008   int result;
59009
59010   {
59011     try {
59012       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59013     } catch (std::out_of_range& e) {
59014       {
59015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (std::exception& e) {
59018       {
59019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (Dali::DaliException e) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59024       };
59025     } catch (...) {
59026       {
59027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59028       };
59029     }
59030   }
59031
59032   jresult = (int)result;
59033   return jresult;
59034 }
59035
59036
59037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59038   int jresult ;
59039   int result;
59040
59041   {
59042     try {
59043       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59044     } catch (std::out_of_range& e) {
59045       {
59046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59047       };
59048     } catch (std::exception& e) {
59049       {
59050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59051       };
59052     } catch (Dali::DaliException e) {
59053       {
59054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59055       };
59056     } catch (...) {
59057       {
59058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59059       };
59060     }
59061   }
59062
59063   jresult = (int)result;
59064   return jresult;
59065 }
59066
59067
59068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59069   int jresult ;
59070   int result;
59071
59072   {
59073     try {
59074       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59075     } catch (std::out_of_range& e) {
59076       {
59077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59078       };
59079     } catch (std::exception& e) {
59080       {
59081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59082       };
59083     } catch (Dali::DaliException e) {
59084       {
59085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59086       };
59087     } catch (...) {
59088       {
59089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59090       };
59091     }
59092   }
59093
59094   jresult = (int)result;
59095   return jresult;
59096 }
59097
59098
59099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59100   int jresult ;
59101   int result;
59102
59103   {
59104     try {
59105       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59106     } catch (std::out_of_range& e) {
59107       {
59108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59109       };
59110     } catch (std::exception& e) {
59111       {
59112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59113       };
59114     } catch (Dali::DaliException e) {
59115       {
59116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59117       };
59118     } catch (...) {
59119       {
59120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59121       };
59122     }
59123   }
59124
59125   jresult = (int)result;
59126   return jresult;
59127 }
59128
59129
59130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59131   int jresult ;
59132   int result;
59133
59134   {
59135     try {
59136       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59137     } catch (std::out_of_range& e) {
59138       {
59139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59140       };
59141     } catch (std::exception& e) {
59142       {
59143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (Dali::DaliException e) {
59146       {
59147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59148       };
59149     } catch (...) {
59150       {
59151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59152       };
59153     }
59154   }
59155
59156   jresult = (int)result;
59157   return jresult;
59158 }
59159
59160
59161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59162   int jresult ;
59163   int result;
59164
59165   {
59166     try {
59167       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59168     } catch (std::out_of_range& e) {
59169       {
59170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59171       };
59172     } catch (std::exception& e) {
59173       {
59174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59175       };
59176     } catch (Dali::DaliException e) {
59177       {
59178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59179       };
59180     } catch (...) {
59181       {
59182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59183       };
59184     }
59185   }
59186
59187   jresult = (int)result;
59188   return jresult;
59189 }
59190
59191
59192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59193   void * jresult ;
59194   Dali::Toolkit::Control result;
59195
59196   {
59197     try {
59198       result = Dali::Toolkit::Internal::Control::New();
59199     } catch (std::out_of_range& e) {
59200       {
59201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59202       };
59203     } catch (std::exception& e) {
59204       {
59205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59206       };
59207     } catch (Dali::DaliException e) {
59208       {
59209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59214       };
59215     }
59216   }
59217
59218   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59219   return jresult;
59220 }
59221
59222
59223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59225   std::string *arg2 = 0 ;
59226
59227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59228   if (!jarg2) {
59229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59230     return ;
59231   }
59232   std::string arg2_str(jarg2);
59233   arg2 = &arg2_str;
59234   {
59235     try {
59236       (arg1)->SetStyleName((std::string const &)*arg2);
59237     } catch (std::out_of_range& e) {
59238       {
59239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59240       };
59241     } catch (std::exception& e) {
59242       {
59243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (Dali::DaliException e) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59248       };
59249     } catch (...) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59252       };
59253     }
59254   }
59255
59256
59257   //argout typemap for const std::string&
59258
59259 }
59260
59261
59262 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59263   char * jresult ;
59264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59265   std::string *result = 0 ;
59266
59267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59268   {
59269     try {
59270       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59271     } catch (std::out_of_range& e) {
59272       {
59273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (std::exception& e) {
59276       {
59277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59278       };
59279     } catch (Dali::DaliException e) {
59280       {
59281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59282       };
59283     } catch (...) {
59284       {
59285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59286       };
59287     }
59288   }
59289
59290   jresult = SWIG_csharp_string_callback(result->c_str());
59291   return jresult;
59292 }
59293
59294
59295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59297   Dali::Vector4 *arg2 = 0 ;
59298
59299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59300   arg2 = (Dali::Vector4 *)jarg2;
59301   if (!arg2) {
59302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59303     return ;
59304   }
59305   {
59306     try {
59307       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59308     } catch (std::out_of_range& e) {
59309       {
59310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59311       };
59312     } catch (std::exception& e) {
59313       {
59314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59315       };
59316     } catch (Dali::DaliException e) {
59317       {
59318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59319       };
59320     } catch (...) {
59321       {
59322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59323       };
59324     }
59325   }
59326
59327 }
59328
59329
59330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59331   void * jresult ;
59332   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59333   Dali::Vector4 result;
59334
59335   arg1 = (Dali::Handle *)jarg1;
59336   {
59337     try {
59338       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59339       if (resultMap)
59340       {
59341         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59342         if(type && type->Get<int>() == Visual::COLOR )
59343         {
59344           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59345           if (value)
59346           {
59347             result = value->Get<Vector4>();
59348           }
59349         }
59350       }
59351     } catch (std::out_of_range& e) {
59352       {
59353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59354       };
59355     } catch (std::exception& e) {
59356       {
59357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59358       };
59359     } catch (Dali::DaliException e) {
59360       {
59361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59362       };
59363     } catch (...) {
59364       {
59365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59366       };
59367     }
59368   }
59369
59370   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59371   return jresult;
59372 }
59373
59374
59375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59376   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59377   Dali::Property::Map *arg2 = 0 ;
59378
59379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59380   arg2 = (Dali::Property::Map *)jarg2;
59381   if (!arg2) {
59382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59383     return ;
59384   }
59385   {
59386     try {
59387       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59388     } catch (std::out_of_range& e) {
59389       {
59390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59391       };
59392     } catch (std::exception& e) {
59393       {
59394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59395       };
59396     } catch (Dali::DaliException e) {
59397       {
59398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59399       };
59400     } catch (...) {
59401       {
59402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59403       };
59404     }
59405   }
59406
59407 }
59408
59409
59410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59412
59413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59414   {
59415     try {
59416       (arg1)->ClearBackground();
59417     } catch (std::out_of_range& e) {
59418       {
59419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59420       };
59421     } catch (std::exception& e) {
59422       {
59423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59424       };
59425     } catch (Dali::DaliException e) {
59426       {
59427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59428       };
59429     } catch (...) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59432       };
59433     }
59434   }
59435
59436 }
59437
59438
59439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59441   Dali::Gesture::Type arg2 ;
59442
59443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59444   arg2 = (Dali::Gesture::Type)jarg2;
59445   {
59446     try {
59447       (arg1)->EnableGestureDetection(arg2);
59448     } catch (std::out_of_range& e) {
59449       {
59450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59451       };
59452     } catch (std::exception& e) {
59453       {
59454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59455       };
59456     } catch (Dali::DaliException e) {
59457       {
59458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59459       };
59460     } catch (...) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59463       };
59464     }
59465   }
59466
59467 }
59468
59469
59470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59472   Dali::Gesture::Type arg2 ;
59473
59474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59475   arg2 = (Dali::Gesture::Type)jarg2;
59476   {
59477     try {
59478       (arg1)->DisableGestureDetection(arg2);
59479     } catch (std::out_of_range& e) {
59480       {
59481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59482       };
59483     } catch (std::exception& e) {
59484       {
59485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59486       };
59487     } catch (Dali::DaliException e) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59490       };
59491     } catch (...) {
59492       {
59493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59494       };
59495     }
59496   }
59497
59498 }
59499
59500
59501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59502   void * jresult ;
59503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59504   Dali::PinchGestureDetector result;
59505
59506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59507   {
59508     try {
59509       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59510     } catch (std::out_of_range& e) {
59511       {
59512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59513       };
59514     } catch (std::exception& e) {
59515       {
59516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59517       };
59518     } catch (Dali::DaliException e) {
59519       {
59520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59521       };
59522     } catch (...) {
59523       {
59524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59525       };
59526     }
59527   }
59528
59529   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59530   return jresult;
59531 }
59532
59533
59534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59535   void * jresult ;
59536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59537   Dali::PanGestureDetector result;
59538
59539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59540   {
59541     try {
59542       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59543     } catch (std::out_of_range& e) {
59544       {
59545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59546       };
59547     } catch (std::exception& e) {
59548       {
59549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59550       };
59551     } catch (Dali::DaliException e) {
59552       {
59553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59554       };
59555     } catch (...) {
59556       {
59557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59558       };
59559     }
59560   }
59561
59562   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59563   return jresult;
59564 }
59565
59566
59567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59568   void * jresult ;
59569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59570   Dali::TapGestureDetector result;
59571
59572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59573   {
59574     try {
59575       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59576     } catch (std::out_of_range& e) {
59577       {
59578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (std::exception& e) {
59581       {
59582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59583       };
59584     } catch (Dali::DaliException e) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59587       };
59588     } catch (...) {
59589       {
59590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59591       };
59592     }
59593   }
59594
59595   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59596   return jresult;
59597 }
59598
59599
59600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59601   void * jresult ;
59602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59603   Dali::LongPressGestureDetector result;
59604
59605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59606   {
59607     try {
59608       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59609     } catch (std::out_of_range& e) {
59610       {
59611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59612       };
59613     } catch (std::exception& e) {
59614       {
59615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59616       };
59617     } catch (Dali::DaliException e) {
59618       {
59619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59620       };
59621     } catch (...) {
59622       {
59623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59624       };
59625     }
59626   }
59627
59628   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59629   return jresult;
59630 }
59631
59632
59633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59635   bool arg2 ;
59636
59637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59638   arg2 = jarg2 ? true : false;
59639   {
59640     try {
59641       (arg1)->SetKeyboardNavigationSupport(arg2);
59642     } catch (std::out_of_range& e) {
59643       {
59644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59645       };
59646     } catch (std::exception& e) {
59647       {
59648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59649       };
59650     } catch (Dali::DaliException e) {
59651       {
59652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59653       };
59654     } catch (...) {
59655       {
59656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59657       };
59658     }
59659   }
59660
59661 }
59662
59663
59664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59665   unsigned int jresult ;
59666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59667   bool result;
59668
59669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59670   {
59671     try {
59672       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59673     } catch (std::out_of_range& e) {
59674       {
59675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59676       };
59677     } catch (std::exception& e) {
59678       {
59679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59680       };
59681     } catch (Dali::DaliException e) {
59682       {
59683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59684       };
59685     } catch (...) {
59686       {
59687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59688       };
59689     }
59690   }
59691
59692   jresult = result;
59693   return jresult;
59694 }
59695
59696
59697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59699
59700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59701   {
59702     try {
59703       (arg1)->SetKeyInputFocus();
59704     } catch (std::out_of_range& e) {
59705       {
59706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59707       };
59708     } catch (std::exception& e) {
59709       {
59710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59711       };
59712     } catch (Dali::DaliException e) {
59713       {
59714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59715       };
59716     } catch (...) {
59717       {
59718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59719       };
59720     }
59721   }
59722
59723 }
59724
59725
59726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59727   unsigned int jresult ;
59728   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59729   bool result;
59730
59731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59732   {
59733     try {
59734       result = (bool)(arg1)->HasKeyInputFocus();
59735     } catch (std::out_of_range& e) {
59736       {
59737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59738       };
59739     } catch (std::exception& e) {
59740       {
59741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59742       };
59743     } catch (Dali::DaliException e) {
59744       {
59745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59746       };
59747     } catch (...) {
59748       {
59749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59750       };
59751     }
59752   }
59753
59754   jresult = result;
59755   return jresult;
59756 }
59757
59758
59759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59761
59762   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59763   {
59764     try {
59765       (arg1)->ClearKeyInputFocus();
59766     } catch (std::out_of_range& e) {
59767       {
59768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59769       };
59770     } catch (std::exception& e) {
59771       {
59772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59773       };
59774     } catch (Dali::DaliException e) {
59775       {
59776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59777       };
59778     } catch (...) {
59779       {
59780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59781       };
59782     }
59783   }
59784
59785 }
59786
59787
59788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59790   bool arg2 ;
59791
59792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59793   arg2 = jarg2 ? true : false;
59794   {
59795     try {
59796       (arg1)->SetAsKeyboardFocusGroup(arg2);
59797     } catch (std::out_of_range& e) {
59798       {
59799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59800       };
59801     } catch (std::exception& e) {
59802       {
59803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59804       };
59805     } catch (Dali::DaliException e) {
59806       {
59807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59808       };
59809     } catch (...) {
59810       {
59811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59812       };
59813     }
59814   }
59815
59816 }
59817
59818
59819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59820   unsigned int jresult ;
59821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59822   bool result;
59823
59824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59825   {
59826     try {
59827       result = (bool)(arg1)->IsKeyboardFocusGroup();
59828     } catch (std::out_of_range& e) {
59829       {
59830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59831       };
59832     } catch (std::exception& e) {
59833       {
59834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59835       };
59836     } catch (Dali::DaliException e) {
59837       {
59838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59839       };
59840     } catch (...) {
59841       {
59842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59843       };
59844     }
59845   }
59846
59847   jresult = result;
59848   return jresult;
59849 }
59850
59851
59852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59853   void * jresult ;
59854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59855   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59856
59857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59858   {
59859     try {
59860       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59861     } catch (std::out_of_range& e) {
59862       {
59863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59864       };
59865     } catch (std::exception& e) {
59866       {
59867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59868       };
59869     } catch (Dali::DaliException e) {
59870       {
59871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59872       };
59873     } catch (...) {
59874       {
59875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59876       };
59877     }
59878   }
59879
59880   jresult = (void *)result;
59881   return jresult;
59882 }
59883
59884
59885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59886   void * jresult ;
59887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59888   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59889
59890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59891   {
59892     try {
59893       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59894     } catch (std::out_of_range& e) {
59895       {
59896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59897       };
59898     } catch (std::exception& e) {
59899       {
59900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (Dali::DaliException e) {
59903       {
59904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59905       };
59906     } catch (...) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59909       };
59910     }
59911   }
59912
59913   jresult = (void *)result;
59914   return jresult;
59915 }
59916
59917
59918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59919   void * jresult ;
59920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59921   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59922
59923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59924   {
59925     try {
59926       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59927     } catch (std::out_of_range& e) {
59928       {
59929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59930       };
59931     } catch (std::exception& e) {
59932       {
59933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59934       };
59935     } catch (Dali::DaliException e) {
59936       {
59937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59938       };
59939     } catch (...) {
59940       {
59941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59942       };
59943     }
59944   }
59945
59946   jresult = (void *)result;
59947   return jresult;
59948 }
59949
59950
59951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59952   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59953   int arg2 ;
59954   SwigDirector_ViewImpl *darg = 0;
59955
59956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59957   arg2 = (int)jarg2;
59958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59959   if(!darg) {
59960     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59961     return;
59962   }
59963   {
59964     try {
59965       if(darg) {
59966         (darg)->OnSceneConnection(arg2);
59967       }
59968     } catch (std::out_of_range& e) {
59969       {
59970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59971       };
59972     } catch (std::exception& e) {
59973       {
59974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59975       };
59976     } catch (Dali::DaliException e) {
59977       {
59978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59979       };
59980     } catch (...) {
59981       {
59982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59983       };
59984     }
59985   }
59986
59987 }
59988
59989
59990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59992   int arg2 ;
59993   SwigDirector_ViewImpl *darg = 0;
59994
59995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59996   arg2 = (int)jarg2;
59997   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59998   if(!darg) {
59999     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60000     return;
60001   }
60002   {
60003     try {
60004       if(darg) {
60005         (darg)->OnSceneConnectionSwigPublic(arg2);
60006       }
60007     } catch (std::out_of_range& e) {
60008       {
60009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60010       };
60011     } catch (std::exception& e) {
60012       {
60013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60014       };
60015     } catch (Dali::DaliException e) {
60016       {
60017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60018       };
60019     } catch (...) {
60020       {
60021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60022       };
60023     }
60024   }
60025
60026 }
60027
60028
60029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
60030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60031   SwigDirector_ViewImpl *darg = 0;
60032
60033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60035   if(!darg) {
60036     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60037     return;
60038   }
60039   {
60040     try {
60041       if(darg) {
60042         (darg)->OnSceneDisconnection();
60043       }
60044     } catch (std::out_of_range& e) {
60045       {
60046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60047       };
60048     } catch (std::exception& e) {
60049       {
60050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60051       };
60052     } catch (Dali::DaliException e) {
60053       {
60054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60055       };
60056     } catch (...) {
60057       {
60058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60059       };
60060     }
60061   }
60062
60063 }
60064
60065
60066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
60067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60068   SwigDirector_ViewImpl *darg = 0;
60069
60070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60071   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60072   if(!darg) {
60073     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60074     return;
60075   }
60076   {
60077     try {
60078       if(darg) {
60079         (darg)->OnSceneDisconnectionSwigPublic();
60080       }
60081     } catch (std::out_of_range& e) {
60082       {
60083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60084       };
60085     } catch (std::exception& e) {
60086       {
60087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60088       };
60089     } catch (Dali::DaliException e) {
60090       {
60091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60092       };
60093     } catch (...) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60096       };
60097     }
60098   }
60099
60100 }
60101
60102
60103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60105   Dali::Actor *arg2 = 0 ;
60106   SwigDirector_ViewImpl *darg = 0;
60107
60108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60109   arg2 = (Dali::Actor *)jarg2;
60110   if (!arg2) {
60111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60112     return ;
60113   }
60114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60115   if(!darg) {
60116     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60117     return;
60118   }
60119   {
60120     try {
60121       if(darg) {
60122         (darg)->OnChildAdd(*arg2);
60123       }
60124     } catch (std::out_of_range& e) {
60125       {
60126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60127       };
60128     } catch (std::exception& e) {
60129       {
60130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60131       };
60132     } catch (Dali::DaliException e) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60135       };
60136     } catch (...) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60139       };
60140     }
60141   }
60142
60143 }
60144
60145
60146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60148   Dali::Actor *arg2 = 0 ;
60149   SwigDirector_ViewImpl *darg = 0;
60150
60151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60152   arg2 = (Dali::Actor *)jarg2;
60153   if (!arg2) {
60154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60155     return ;
60156   }
60157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60158   if(!darg) {
60159     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60160     return;
60161   }
60162   {
60163     try {
60164       if(darg) {
60165           (darg)->OnChildAddSwigPublic(*arg2);
60166       }
60167     } catch (std::out_of_range& e) {
60168       {
60169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60170       };
60171     } catch (std::exception& e) {
60172       {
60173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60174       };
60175     } catch (Dali::DaliException e) {
60176       {
60177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60178       };
60179     } catch (...) {
60180       {
60181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60182       };
60183     }
60184   }
60185
60186 }
60187
60188
60189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60191   Dali::Actor *arg2 = 0 ;
60192   SwigDirector_ViewImpl *darg = 0;
60193
60194   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60195   arg2 = (Dali::Actor *)jarg2;
60196   if (!arg2) {
60197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60198     return ;
60199   }
60200   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60201   if(!darg) {
60202     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60203     return;
60204   }
60205   {
60206     try {
60207       if(darg) {
60208         (darg)->OnChildRemove(*arg2);
60209       }
60210     } catch (std::out_of_range& e) {
60211       {
60212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60213       };
60214     } catch (std::exception& e) {
60215       {
60216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60217       };
60218     } catch (Dali::DaliException e) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60221       };
60222     } catch (...) {
60223       {
60224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60225       };
60226     }
60227   }
60228
60229 }
60230
60231
60232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60234   Dali::Actor *arg2 = 0 ;
60235   SwigDirector_ViewImpl *darg = 0;
60236
60237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60238   arg2 = (Dali::Actor *)jarg2;
60239   if (!arg2) {
60240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60241     return ;
60242   }
60243   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60244   if(!darg) {
60245     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60246     return;
60247   }
60248   {
60249     try {
60250       if(darg) {
60251         (darg)->OnChildRemoveSwigPublic(*arg2);
60252       }
60253     } catch (std::out_of_range& e) {
60254       {
60255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60256       };
60257     } catch (std::exception& e) {
60258       {
60259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60260       };
60261     } catch (Dali::DaliException e) {
60262       {
60263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60264       };
60265     } catch (...) {
60266       {
60267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60268       };
60269     }
60270   }
60271
60272 }
60273
60274
60275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60277   Dali::Property::Index arg2 ;
60278   Dali::Property::Value arg3 ;
60279   Dali::Property::Value *argp3 ;
60280   SwigDirector_ViewImpl *darg = 0;
60281
60282   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60283   arg2 = (Dali::Property::Index)jarg2;
60284   argp3 = (Dali::Property::Value *)jarg3;
60285   if (!argp3) {
60286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60287     return ;
60288   }
60289   arg3 = *argp3;
60290   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60291   if (!darg) {
60292     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60293     return;
60294   }
60295   {
60296     try {
60297       (darg)->OnPropertySet(arg2,arg3);
60298     } catch (std::out_of_range& e) {
60299       {
60300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60301       };
60302     } catch (std::exception& e) {
60303       {
60304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60305       };
60306     } catch (Dali::DaliException e) {
60307       {
60308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60309       };
60310     } catch (...) {
60311       {
60312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60313       };
60314     }
60315   }
60316
60317 }
60318
60319
60320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60321   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60322   Dali::Property::Index arg2 ;
60323   Dali::Property::Value arg3 ;
60324   Dali::Property::Value *argp3 ;
60325   SwigDirector_ViewImpl *darg = 0;
60326
60327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60328   arg2 = (Dali::Property::Index)jarg2;
60329   argp3 = (Dali::Property::Value *)jarg3;
60330   if (!argp3) {
60331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60332     return ;
60333   }
60334   arg3 = *argp3;
60335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60336   if (!darg) {
60337     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60338     return;
60339   }
60340   {
60341     try {
60342       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60343     } catch (std::out_of_range& e) {
60344       {
60345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60346       };
60347     } catch (std::exception& e) {
60348       {
60349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60350       };
60351     } catch (Dali::DaliException e) {
60352       {
60353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60354       };
60355     } catch (...) {
60356       {
60357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60358       };
60359     }
60360   }
60361
60362 }
60363
60364
60365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60367   Dali::Vector3 *arg2 = 0 ;
60368   SwigDirector_ViewImpl *darg = 0;
60369
60370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60371   arg2 = (Dali::Vector3 *)jarg2;
60372   if (!arg2) {
60373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60374     return ;
60375   }
60376   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60377   if (!darg) {
60378     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60379     return;
60380   }
60381   {
60382     try {
60383       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60384     } catch (std::out_of_range& e) {
60385       {
60386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60387       };
60388     } catch (std::exception& e) {
60389       {
60390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60391       };
60392     } catch (Dali::DaliException e) {
60393       {
60394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60395       };
60396     } catch (...) {
60397       {
60398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60399       };
60400     }
60401   }
60402
60403 }
60404
60405
60406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60408   Dali::Vector3 *arg2 = 0 ;
60409   SwigDirector_ViewImpl *darg = 0;
60410
60411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60412   arg2 = (Dali::Vector3 *)jarg2;
60413   if (!arg2) {
60414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60415     return ;
60416   }
60417   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60418   if (!darg) {
60419     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60420     return;
60421   }
60422   {
60423     try {
60424       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60425     } catch (std::out_of_range& e) {
60426       {
60427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60428       };
60429     } catch (std::exception& e) {
60430       {
60431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60432       };
60433     } catch (Dali::DaliException e) {
60434       {
60435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60436       };
60437     } catch (...) {
60438       {
60439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60440       };
60441     }
60442   }
60443
60444 }
60445
60446
60447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60448   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60449   Dali::Animation *arg2 = 0 ;
60450   Dali::Vector3 *arg3 = 0 ;
60451   SwigDirector_ViewImpl *darg = 0;
60452
60453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60454   arg2 = (Dali::Animation *)jarg2;
60455   if (!arg2) {
60456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60457     return ;
60458   }
60459   arg3 = (Dali::Vector3 *)jarg3;
60460   if (!arg3) {
60461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60462     return ;
60463   }
60464   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60465   if (!darg) {
60466     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60467     return;
60468   }
60469   {
60470     try {
60471       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60472     } catch (std::out_of_range& e) {
60473       {
60474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60475       };
60476     } catch (std::exception& e) {
60477       {
60478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60479       };
60480     } catch (Dali::DaliException e) {
60481       {
60482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60483       };
60484     } catch (...) {
60485       {
60486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60487       };
60488     }
60489   }
60490
60491 }
60492
60493
60494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60496   Dali::Animation *arg2 = 0 ;
60497   Dali::Vector3 *arg3 = 0 ;
60498   SwigDirector_ViewImpl *darg = 0;
60499
60500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60501   arg2 = (Dali::Animation *)jarg2;
60502   if (!arg2) {
60503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60504     return ;
60505   }
60506   arg3 = (Dali::Vector3 *)jarg3;
60507   if (!arg3) {
60508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60509     return ;
60510   }
60511   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60512   if (!darg) {
60513     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60514     return;
60515   }
60516   {
60517     try {
60518       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60526       };
60527     } catch (Dali::DaliException e) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60530       };
60531     } catch (...) {
60532       {
60533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60534       };
60535     }
60536   }
60537
60538 }
60539
60540
60541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60542   unsigned int jresult ;
60543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60544   Dali::TouchEvent *arg2 = 0 ;
60545   SwigDirector_ViewImpl *darg = 0;
60546   bool result;
60547
60548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60549   arg2 = (Dali::TouchEvent *)jarg2;
60550   if (!arg2) {
60551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60552     return 0;
60553   }
60554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60555   if (!darg) {
60556     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60557     return 0;
60558   }
60559   {
60560     try {
60561       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60562     } catch (std::out_of_range& e) {
60563       {
60564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60565       };
60566     } catch (std::exception& e) {
60567       {
60568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60569       };
60570     } catch (Dali::DaliException e) {
60571       {
60572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60573       };
60574     } catch (...) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60577       };
60578     }
60579   }
60580
60581   jresult = result;
60582   return jresult;
60583 }
60584
60585
60586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60587   unsigned int jresult ;
60588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60589   Dali::TouchEvent *arg2 = 0 ;
60590   SwigDirector_ViewImpl *darg = 0;
60591   bool result;
60592
60593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60594   arg2 = (Dali::TouchEvent *)jarg2;
60595   if (!arg2) {
60596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60597     return 0;
60598   }
60599   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60600   if (!darg) {
60601     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60602     return 0;
60603   }
60604   {
60605     try {
60606       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60607     } catch (std::out_of_range& e) {
60608       {
60609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60610       };
60611     } catch (std::exception& e) {
60612       {
60613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (Dali::DaliException e) {
60616       {
60617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625
60626   jresult = result;
60627   return jresult;
60628 }
60629
60630
60631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60632   unsigned int jresult ;
60633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60634   Dali::HoverEvent *arg2 = 0 ;
60635   SwigDirector_ViewImpl *darg = 0;
60636   bool result;
60637
60638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60639   arg2 = (Dali::HoverEvent *)jarg2;
60640   if (!arg2) {
60641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60642     return 0;
60643   }
60644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60645   if (!darg) {
60646     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60647     return 0;
60648   }
60649   {
60650     try {
60651       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60652     } catch (std::out_of_range& e) {
60653       {
60654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (std::exception& e) {
60657       {
60658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60659       };
60660     } catch (Dali::DaliException e) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60663       };
60664     } catch (...) {
60665       {
60666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60667       };
60668     }
60669   }
60670
60671   jresult = result;
60672   return jresult;
60673 }
60674
60675
60676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60677   unsigned int jresult ;
60678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60679   Dali::HoverEvent *arg2 = 0 ;
60680   SwigDirector_ViewImpl *darg = 0;
60681   bool result;
60682
60683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60684   arg2 = (Dali::HoverEvent *)jarg2;
60685   if (!arg2) {
60686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60687     return 0;
60688   }
60689   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60690   if (!darg) {
60691     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60692     return 0;
60693   }
60694   {
60695     try {
60696       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60697     } catch (std::out_of_range& e) {
60698       {
60699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60700       };
60701     } catch (std::exception& e) {
60702       {
60703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (Dali::DaliException e) {
60706       {
60707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60712       };
60713     }
60714   }
60715
60716   jresult = result;
60717   return jresult;
60718 }
60719
60720
60721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60722   unsigned int jresult ;
60723   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60724   Dali::KeyEvent *arg2 = 0 ;
60725   SwigDirector_ViewImpl *darg = 0;
60726   bool result;
60727
60728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60729   arg2 = (Dali::KeyEvent *)jarg2;
60730   if (!arg2) {
60731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60732     return 0;
60733   }
60734   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60735   if (!darg) {
60736     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60737     return 0;
60738   }
60739   {
60740     try {
60741       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60742     } catch (std::out_of_range& e) {
60743       {
60744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60745       };
60746     } catch (std::exception& e) {
60747       {
60748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60749       };
60750     } catch (Dali::DaliException e) {
60751       {
60752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60753       };
60754     } catch (...) {
60755       {
60756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60757       };
60758     }
60759   }
60760
60761   jresult = result;
60762   return jresult;
60763 }
60764
60765
60766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60767   unsigned int jresult ;
60768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60769   Dali::KeyEvent *arg2 = 0 ;
60770   SwigDirector_ViewImpl *darg = 0;
60771   bool result;
60772
60773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60774   arg2 = (Dali::KeyEvent *)jarg2;
60775   if (!arg2) {
60776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60777     return 0;
60778   }
60779   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60780   if (!darg) {
60781     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60782     return 0;
60783   }
60784   {
60785     try {
60786       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60787     } catch (std::out_of_range& e) {
60788       {
60789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60790       };
60791     } catch (std::exception& e) {
60792       {
60793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (Dali::DaliException e) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60798       };
60799     } catch (...) {
60800       {
60801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60802       };
60803     }
60804   }
60805
60806   jresult = result;
60807   return jresult;
60808 }
60809
60810
60811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60812   unsigned int jresult ;
60813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60814   Dali::WheelEvent *arg2 = 0 ;
60815   SwigDirector_ViewImpl *darg = 0;
60816   bool result;
60817
60818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60819   arg2 = (Dali::WheelEvent *)jarg2;
60820   if (!arg2) {
60821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60822     return 0;
60823   }
60824   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60825   if (!darg) {
60826     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60827     return 0;
60828   }
60829   {
60830     try {
60831       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60832     } catch (std::out_of_range& e) {
60833       {
60834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60835       };
60836     } catch (std::exception& e) {
60837       {
60838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60839       };
60840     } catch (Dali::DaliException e) {
60841       {
60842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60843       };
60844     } catch (...) {
60845       {
60846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60847       };
60848     }
60849   }
60850
60851   jresult = result;
60852   return jresult;
60853 }
60854
60855
60856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60857   unsigned int jresult ;
60858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60859   Dali::WheelEvent *arg2 = 0 ;
60860   SwigDirector_ViewImpl *darg = 0;
60861   bool result;
60862
60863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60864   arg2 = (Dali::WheelEvent *)jarg2;
60865   if (!arg2) {
60866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60867     return 0;
60868   }
60869   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60870   if (!darg) {
60871     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60872     return 0;
60873   }
60874   {
60875     try {
60876       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60877     } catch (std::out_of_range& e) {
60878       {
60879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60880       };
60881     } catch (std::exception& e) {
60882       {
60883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60884       };
60885     } catch (Dali::DaliException e) {
60886       {
60887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60888       };
60889     } catch (...) {
60890       {
60891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60892       };
60893     }
60894   }
60895
60896   jresult = result;
60897   return jresult;
60898 }
60899
60900
60901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60902   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60903   Dali::Vector2 *arg2 = 0 ;
60904   Dali::RelayoutContainer *arg3 = 0 ;
60905   SwigDirector_ViewImpl *darg = 0;
60906
60907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60908   arg2 = (Dali::Vector2 *)jarg2;
60909   if (!arg2) {
60910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60911     return ;
60912   }
60913   arg3 = (Dali::RelayoutContainer *)jarg3;
60914   if (!arg3) {
60915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60916     return ;
60917   }
60918   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60919   if (!darg) {
60920     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60921     return;
60922   }
60923   {
60924     try {
60925       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60926     } catch (std::out_of_range& e) {
60927       {
60928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60929       };
60930     } catch (std::exception& e) {
60931       {
60932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60933       };
60934     } catch (Dali::DaliException e) {
60935       {
60936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60937       };
60938     } catch (...) {
60939       {
60940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60941       };
60942     }
60943   }
60944
60945 }
60946
60947
60948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60950   Dali::Vector2 *arg2 = 0 ;
60951   Dali::RelayoutContainer *arg3 = 0 ;
60952   SwigDirector_ViewImpl *darg = 0;
60953
60954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60955   arg2 = (Dali::Vector2 *)jarg2;
60956   if (!arg2) {
60957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60958     return ;
60959   }
60960   arg3 = (Dali::RelayoutContainer *)jarg3;
60961   if (!arg3) {
60962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60963     return ;
60964   }
60965   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60966   if (!darg) {
60967     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60968     return;
60969   }
60970   {
60971     try {
60972       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60973     } catch (std::out_of_range& e) {
60974       {
60975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60976       };
60977     } catch (std::exception& e) {
60978       {
60979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60980       };
60981     } catch (Dali::DaliException e) {
60982       {
60983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60984       };
60985     } catch (...) {
60986       {
60987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60988       };
60989     }
60990   }
60991
60992 }
60993
60994
60995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60996   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60997   Dali::ResizePolicy::Type arg2 ;
60998   Dali::Dimension::Type arg3 ;
60999   SwigDirector_ViewImpl *darg = 0;
61000
61001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61002   arg2 = (Dali::ResizePolicy::Type)jarg2;
61003   arg3 = (Dali::Dimension::Type)jarg3;
61004   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61005   if (!darg) {
61006     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61007     return;
61008   }
61009   {
61010     try {
61011       (darg)->OnSetResizePolicy(arg2,arg3);
61012     } catch (std::out_of_range& e) {
61013       {
61014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61015       };
61016     } catch (std::exception& e) {
61017       {
61018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61019       };
61020     } catch (Dali::DaliException e) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61023       };
61024     } catch (...) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61027       };
61028     }
61029   }
61030
61031 }
61032
61033
61034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61036   Dali::ResizePolicy::Type arg2 ;
61037   Dali::Dimension::Type arg3 ;
61038   SwigDirector_ViewImpl *darg = 0;
61039
61040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61041   arg2 = (Dali::ResizePolicy::Type)jarg2;
61042   arg3 = (Dali::Dimension::Type)jarg3;
61043   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61044   if (!darg) {
61045     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61046     return;
61047   }
61048   {
61049     try {
61050       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61051     } catch (std::out_of_range& e) {
61052       {
61053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61054       };
61055     } catch (std::exception& e) {
61056       {
61057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61058       };
61059     } catch (Dali::DaliException e) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61062       };
61063     } catch (...) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61066       };
61067     }
61068   }
61069
61070 }
61071
61072
61073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61074   void * jresult ;
61075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61076   SwigDirector_ViewImpl *darg = 0;
61077   Dali::Vector3 result;
61078
61079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61080   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61081   if (!darg) {
61082     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61083     return 0;
61084   }
61085   {
61086     try {
61087       result = (darg)->GetNaturalSize();
61088     } catch (std::out_of_range& e) {
61089       {
61090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61091       };
61092     } catch (std::exception& e) {
61093       {
61094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61095       };
61096     } catch (Dali::DaliException e) {
61097       {
61098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61099       };
61100     } catch (...) {
61101       {
61102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61103       };
61104     }
61105   }
61106
61107   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61108   return jresult;
61109 }
61110
61111
61112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61113   void * jresult ;
61114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61115   SwigDirector_ViewImpl *darg = 0;
61116   Dali::Vector3 result;
61117
61118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61119   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61120   if (!darg) {
61121     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61122     return 0;
61123   }
61124   {
61125     try {
61126       result = (darg)->GetNaturalSizeSwigPublic();
61127     } catch (std::out_of_range& e) {
61128       {
61129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61130       };
61131     } catch (std::exception& e) {
61132       {
61133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61134       };
61135     } catch (Dali::DaliException e) {
61136       {
61137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61138       };
61139     } catch (...) {
61140       {
61141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61142       };
61143     }
61144   }
61145
61146   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61147   return jresult;
61148 }
61149
61150
61151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61152   float jresult ;
61153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61154   Dali::Actor *arg2 = 0 ;
61155   Dali::Dimension::Type arg3 ;
61156   SwigDirector_ViewImpl *darg = 0;
61157   float result;
61158
61159   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61160   arg2 = (Dali::Actor *)jarg2;
61161   if (!arg2) {
61162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61163     return 0;
61164   }
61165   arg3 = (Dali::Dimension::Type)jarg3;
61166   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61167   if (!darg) {
61168     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61169     return 0;
61170   }
61171   {
61172     try {
61173       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (Dali::DaliException e) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61185       };
61186     } catch (...) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61189       };
61190     }
61191   }
61192
61193   jresult = result;
61194   return jresult;
61195 }
61196
61197
61198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61199   float jresult ;
61200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61201   Dali::Actor *arg2 = 0 ;
61202   Dali::Dimension::Type arg3 ;
61203   SwigDirector_ViewImpl *darg = 0;
61204   float result;
61205
61206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61207   arg2 = (Dali::Actor *)jarg2;
61208   if (!arg2) {
61209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61210     return 0;
61211   }
61212   arg3 = (Dali::Dimension::Type)jarg3;
61213   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61214   if (!darg) {
61215     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61216     return 0;
61217   }
61218   {
61219     try {
61220       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61221     } catch (std::out_of_range& e) {
61222       {
61223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61224       };
61225     } catch (std::exception& e) {
61226       {
61227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61228       };
61229     } catch (Dali::DaliException e) {
61230       {
61231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61232       };
61233     } catch (...) {
61234       {
61235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61236       };
61237     }
61238   }
61239
61240   jresult = result;
61241   return jresult;
61242 }
61243
61244
61245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61246   float jresult ;
61247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61248   float arg2 ;
61249   SwigDirector_ViewImpl *darg = 0;
61250   float result;
61251
61252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61253   arg2 = (float)jarg2;
61254   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61255   if (!darg) {
61256     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61257     return 0;
61258   }
61259   {
61260     try {
61261       result = (float)(darg)->GetHeightForWidth(arg2);
61262     } catch (std::out_of_range& e) {
61263       {
61264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61265       };
61266     } catch (std::exception& e) {
61267       {
61268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61269       };
61270     } catch (Dali::DaliException e) {
61271       {
61272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61273       };
61274     } catch (...) {
61275       {
61276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61277       };
61278     }
61279   }
61280
61281   jresult = result;
61282   return jresult;
61283 }
61284
61285
61286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61287   float jresult ;
61288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61289   float arg2 ;
61290   SwigDirector_ViewImpl *darg = 0;
61291   float result;
61292
61293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61294   arg2 = (float)jarg2;
61295   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61296   if (!darg) {
61297     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61298     return 0;
61299   }
61300   {
61301     try {
61302       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61303     } catch (std::out_of_range& e) {
61304       {
61305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61306       };
61307     } catch (std::exception& e) {
61308       {
61309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61310       };
61311     } catch (Dali::DaliException e) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61314       };
61315     } catch (...) {
61316       {
61317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61318       };
61319     }
61320   }
61321
61322   jresult = result;
61323   return jresult;
61324 }
61325
61326
61327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61328   float jresult ;
61329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61330   float arg2 ;
61331   SwigDirector_ViewImpl *darg = 0;
61332   float result;
61333
61334   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61335   arg2 = (float)jarg2;
61336   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61337   if (!darg) {
61338     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61339     return 0;
61340   }
61341   {
61342     try {
61343       result = (float)(darg)->GetWidthForHeight(arg2);
61344     } catch (std::out_of_range& e) {
61345       {
61346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61347       };
61348     } catch (std::exception& e) {
61349       {
61350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61351       };
61352     } catch (Dali::DaliException e) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61355       };
61356     } catch (...) {
61357       {
61358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61359       };
61360     }
61361   }
61362
61363   jresult = result;
61364   return jresult;
61365 }
61366
61367
61368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61369   float jresult ;
61370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61371   float arg2 ;
61372   SwigDirector_ViewImpl *darg = 0;
61373   float result;
61374
61375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61376   arg2 = (float)jarg2;
61377   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61378   if (!darg) {
61379     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61380     return 0;
61381   }
61382   {
61383     try {
61384       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61385     } catch (std::out_of_range& e) {
61386       {
61387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61388       };
61389     } catch (std::exception& e) {
61390       {
61391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61392       };
61393     } catch (Dali::DaliException e) {
61394       {
61395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61396       };
61397     } catch (...) {
61398       {
61399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61400       };
61401     }
61402   }
61403
61404   jresult = result;
61405   return jresult;
61406 }
61407
61408
61409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61410   unsigned int jresult ;
61411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61412   Dali::Dimension::Type arg2 ;
61413   SwigDirector_ViewImpl *darg = 0;
61414   bool result;
61415
61416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61417   arg2 = (Dali::Dimension::Type)jarg2;
61418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61419   if (!darg) {
61420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61421     return 0;
61422   }
61423   {
61424     try {
61425       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61426     } catch (std::out_of_range& e) {
61427       {
61428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61429       };
61430     } catch (std::exception& e) {
61431       {
61432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61433       };
61434     } catch (Dali::DaliException e) {
61435       {
61436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61437       };
61438     } catch (...) {
61439       {
61440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61441       };
61442     }
61443   }
61444
61445   jresult = result;
61446   return jresult;
61447 }
61448
61449
61450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61451   unsigned int jresult ;
61452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61453   Dali::Dimension::Type arg2 ;
61454   SwigDirector_ViewImpl *darg = 0;
61455   bool result;
61456
61457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61458   arg2 = (Dali::Dimension::Type)jarg2;
61459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61460   if (!darg) {
61461     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61462     return 0;
61463   }
61464   {
61465     try {
61466       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61467     } catch (std::out_of_range& e) {
61468       {
61469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61470       };
61471     } catch (std::exception& e) {
61472       {
61473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61474       };
61475     } catch (Dali::DaliException e) {
61476       {
61477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61478       };
61479     } catch (...) {
61480       {
61481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61482       };
61483     }
61484   }
61485
61486   jresult = result;
61487   return jresult;
61488 }
61489
61490
61491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61492   unsigned int jresult ;
61493   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61494   SwigDirector_ViewImpl *darg = 0;
61495   bool result;
61496
61497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61498   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61499   if (!darg) {
61500     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61501     return 0;
61502   }
61503   {
61504     try {
61505       result = (bool)(darg)->RelayoutDependentOnChildren();
61506     } catch (std::out_of_range& e) {
61507       {
61508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61509       };
61510     } catch (std::exception& e) {
61511       {
61512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61513       };
61514     } catch (Dali::DaliException e) {
61515       {
61516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61517       };
61518     } catch (...) {
61519       {
61520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61521       };
61522     }
61523   }
61524
61525   jresult = result;
61526   return jresult;
61527 }
61528
61529
61530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61531   unsigned int jresult ;
61532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61533   SwigDirector_ViewImpl *darg = 0;
61534   bool result;
61535
61536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61537   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61538   if (!darg) {
61539     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61540     return 0;
61541   }
61542   {
61543     try {
61544       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61545     } catch (std::out_of_range& e) {
61546       {
61547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61548       };
61549     } catch (std::exception& e) {
61550       {
61551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61552       };
61553     } catch (Dali::DaliException e) {
61554       {
61555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61556       };
61557     } catch (...) {
61558       {
61559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61560       };
61561     }
61562   }
61563
61564   jresult = result;
61565   return jresult;
61566 }
61567
61568
61569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61571   Dali::Dimension::Type arg2 ;
61572   SwigDirector_ViewImpl *darg = 0;
61573
61574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61575   arg2 = (Dali::Dimension::Type)jarg2;
61576   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61577   if (!darg) {
61578     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61579     return;
61580   }
61581   {
61582     try {
61583       (darg)->OnCalculateRelayoutSize(arg2);
61584     } catch (std::out_of_range& e) {
61585       {
61586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61587       };
61588     } catch (std::exception& e) {
61589       {
61590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61591       };
61592     } catch (Dali::DaliException e) {
61593       {
61594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61595       };
61596     } catch (...) {
61597       {
61598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61599       };
61600     }
61601   }
61602
61603 }
61604
61605
61606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61608   Dali::Dimension::Type arg2 ;
61609   SwigDirector_ViewImpl *darg = 0;
61610
61611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61612   arg2 = (Dali::Dimension::Type)jarg2;
61613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61614   if (!darg) {
61615     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61616     return;
61617   }
61618   {
61619     try {
61620       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61621     } catch (std::out_of_range& e) {
61622       {
61623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61624       };
61625     } catch (std::exception& e) {
61626       {
61627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61628       };
61629     } catch (Dali::DaliException e) {
61630       {
61631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61632       };
61633     } catch (...) {
61634       {
61635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61636       };
61637     }
61638   }
61639
61640 }
61641
61642
61643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61644   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61645   float arg2 ;
61646   Dali::Dimension::Type arg3 ;
61647   SwigDirector_ViewImpl *darg = 0;
61648
61649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61650   arg2 = (float)jarg2;
61651   arg3 = (Dali::Dimension::Type)jarg3;
61652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61653   if (!darg) {
61654     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61655     return;
61656   }
61657   {
61658     try {
61659       (darg)->OnLayoutNegotiated(arg2,arg3);
61660     } catch (std::out_of_range& e) {
61661       {
61662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61663       };
61664     } catch (std::exception& e) {
61665       {
61666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61667       };
61668     } catch (Dali::DaliException e) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61671       };
61672     } catch (...) {
61673       {
61674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61675       };
61676     }
61677   }
61678
61679 }
61680
61681
61682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61684   float arg2 ;
61685   Dali::Dimension::Type arg3 ;
61686   SwigDirector_ViewImpl *darg = 0;
61687
61688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61689   arg2 = (float)jarg2;
61690   arg3 = (Dali::Dimension::Type)jarg3;
61691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61692   if (!darg) {
61693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61694     return;
61695   }
61696   {
61697     try {
61698       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61699     } catch (std::out_of_range& e) {
61700       {
61701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61702       };
61703     } catch (std::exception& e) {
61704       {
61705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61706       };
61707     } catch (Dali::DaliException e) {
61708       {
61709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61710       };
61711     } catch (...) {
61712       {
61713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61714       };
61715     }
61716   }
61717
61718 }
61719
61720
61721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61722   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61723
61724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61725   {
61726     try {
61727       (arg1)->OnInitialize();
61728     } catch (std::out_of_range& e) {
61729       {
61730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61731       };
61732     } catch (std::exception& e) {
61733       {
61734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61735       };
61736     } catch (Dali::DaliException e) {
61737       {
61738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61739       };
61740     } catch (...) {
61741       {
61742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61743       };
61744     }
61745   }
61746
61747 }
61748
61749
61750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61751   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61752
61753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61754   {
61755     try {
61756       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61757     } catch (std::out_of_range& e) {
61758       {
61759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61760       };
61761     } catch (std::exception& e) {
61762       {
61763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61764       };
61765     } catch (Dali::DaliException e) {
61766       {
61767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61768       };
61769     } catch (...) {
61770       {
61771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61772       };
61773     }
61774   }
61775
61776 }
61777
61778
61779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61781   Dali::Toolkit::StyleManager arg2 ;
61782   Dali::StyleChange::Type arg3 ;
61783   Dali::Toolkit::StyleManager *argp2 ;
61784
61785   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61786   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61787   if (!argp2) {
61788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61789     return ;
61790   }
61791   arg2 = *argp2;
61792   arg3 = (Dali::StyleChange::Type)jarg3;
61793   {
61794     try {
61795       (arg1)->OnStyleChange(arg2,arg3);
61796     } catch (std::out_of_range& e) {
61797       {
61798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61799       };
61800     } catch (std::exception& e) {
61801       {
61802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61803       };
61804     } catch (Dali::DaliException e) {
61805       {
61806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61807       };
61808     } catch (...) {
61809       {
61810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61811       };
61812     }
61813   }
61814
61815 }
61816
61817
61818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61820   Dali::Toolkit::StyleManager arg2 ;
61821   Dali::StyleChange::Type arg3 ;
61822   Dali::Toolkit::StyleManager *argp2 ;
61823
61824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61825   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61826   if (!argp2) {
61827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61828     return ;
61829   }
61830   arg2 = *argp2;
61831   arg3 = (Dali::StyleChange::Type)jarg3;
61832   {
61833     try {
61834       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61835     } catch (std::out_of_range& e) {
61836       {
61837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61838       };
61839     } catch (std::exception& e) {
61840       {
61841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61842       };
61843     } catch (Dali::DaliException e) {
61844       {
61845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61846       };
61847     } catch (...) {
61848       {
61849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61850       };
61851     }
61852   }
61853
61854 }
61855
61856
61857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61858   unsigned int jresult ;
61859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61860   bool result;
61861
61862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61863   {
61864     try {
61865       result = (bool)(arg1)->OnAccessibilityActivated();
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61873       };
61874     } catch (Dali::DaliException e) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61877       };
61878     } catch (...) {
61879       {
61880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61881       };
61882     }
61883   }
61884
61885   jresult = result;
61886   return jresult;
61887 }
61888
61889
61890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61891   unsigned int jresult ;
61892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61893   bool result;
61894
61895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61896   {
61897     try {
61898       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61899     } catch (std::out_of_range& e) {
61900       {
61901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61902       };
61903     } catch (std::exception& e) {
61904       {
61905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61906       };
61907     } catch (Dali::DaliException e) {
61908       {
61909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61910       };
61911     } catch (...) {
61912       {
61913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61914       };
61915     }
61916   }
61917
61918   jresult = result;
61919   return jresult;
61920 }
61921
61922
61923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61924   unsigned int jresult ;
61925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61926   Dali::PanGesture arg2 ;
61927   Dali::PanGesture *argp2 ;
61928   bool result;
61929
61930   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61931   argp2 = (Dali::PanGesture *)jarg2;
61932   if (!argp2) {
61933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61934     return 0;
61935   }
61936   arg2 = *argp2;
61937   {
61938     try {
61939       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61940     } catch (std::out_of_range& e) {
61941       {
61942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61943       };
61944     } catch (std::exception& e) {
61945       {
61946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61947       };
61948     } catch (Dali::DaliException e) {
61949       {
61950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61951       };
61952     } catch (...) {
61953       {
61954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61955       };
61956     }
61957   }
61958
61959   jresult = result;
61960   return jresult;
61961 }
61962
61963
61964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61965   unsigned int jresult ;
61966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61967   Dali::PanGesture arg2 ;
61968   Dali::PanGesture *argp2 ;
61969   bool result;
61970
61971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61972   argp2 = (Dali::PanGesture *)jarg2;
61973   if (!argp2) {
61974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61975     return 0;
61976   }
61977   arg2 = *argp2;
61978   {
61979     try {
61980       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61981     } catch (std::out_of_range& e) {
61982       {
61983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61984       };
61985     } catch (std::exception& e) {
61986       {
61987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61988       };
61989     } catch (Dali::DaliException e) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61992       };
61993     } catch (...) {
61994       {
61995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61996       };
61997     }
61998   }
61999
62000   jresult = result;
62001   return jresult;
62002 }
62003
62004
62005 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62006   unsigned int jresult ;
62007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62008   Dali::TouchEvent *arg2 = 0 ;
62009   bool result;
62010
62011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62012   arg2 = (Dali::TouchEvent *)jarg2;
62013   if (!arg2) {
62014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62015     return 0;
62016   }
62017   {
62018     try {
62019       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62020     } catch (std::out_of_range& e) {
62021       {
62022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62023       };
62024     } catch (std::exception& e) {
62025       {
62026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62027       };
62028     } catch (Dali::DaliException e) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62031       };
62032     } catch (...) {
62033       {
62034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62035       };
62036     }
62037   }
62038
62039   jresult = result;
62040   return jresult;
62041 }
62042
62043
62044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62045   unsigned int jresult ;
62046   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62047   Dali::TouchEvent *arg2 = 0 ;
62048   bool result;
62049
62050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62051   arg2 = (Dali::TouchEvent *)jarg2;
62052   if (!arg2) {
62053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62054     return 0;
62055   }
62056   {
62057     try {
62058       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62059     } catch (std::out_of_range& e) {
62060       {
62061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62062       };
62063     } catch (std::exception& e) {
62064       {
62065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62066       };
62067     } catch (Dali::DaliException e) {
62068       {
62069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62070       };
62071     } catch (...) {
62072       {
62073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62074       };
62075     }
62076   }
62077
62078   jresult = result;
62079   return jresult;
62080 }
62081
62082
62083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62084   unsigned int jresult ;
62085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62086   bool arg2 ;
62087   bool result;
62088
62089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62090   arg2 = jarg2 ? true : false;
62091   {
62092     try {
62093       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62094     } catch (std::out_of_range& e) {
62095       {
62096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62097       };
62098     } catch (std::exception& e) {
62099       {
62100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62101       };
62102     } catch (Dali::DaliException e) {
62103       {
62104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62109       };
62110     }
62111   }
62112
62113   jresult = result;
62114   return jresult;
62115 }
62116
62117
62118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62119   unsigned int jresult ;
62120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62121   bool arg2 ;
62122   bool result;
62123
62124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62125   arg2 = jarg2 ? true : false;
62126   {
62127     try {
62128       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62129     } catch (std::out_of_range& e) {
62130       {
62131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62132       };
62133     } catch (std::exception& e) {
62134       {
62135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62136       };
62137     } catch (Dali::DaliException e) {
62138       {
62139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62140       };
62141     } catch (...) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62144       };
62145     }
62146   }
62147
62148   jresult = result;
62149   return jresult;
62150 }
62151
62152
62153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62154   unsigned int jresult ;
62155   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62156   bool result;
62157
62158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62159   {
62160     try {
62161       result = (bool)(arg1)->OnAccessibilityZoom();
62162     } catch (std::out_of_range& e) {
62163       {
62164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62165       };
62166     } catch (std::exception& e) {
62167       {
62168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62169       };
62170     } catch (Dali::DaliException e) {
62171       {
62172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62173       };
62174     } catch (...) {
62175       {
62176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62177       };
62178     }
62179   }
62180
62181   jresult = result;
62182   return jresult;
62183 }
62184
62185
62186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62187   unsigned int jresult ;
62188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62189   bool result;
62190
62191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62192   {
62193     try {
62194       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62195     } catch (std::out_of_range& e) {
62196       {
62197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62198       };
62199     } catch (std::exception& e) {
62200       {
62201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62202       };
62203     } catch (Dali::DaliException e) {
62204       {
62205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62206       };
62207     } catch (...) {
62208       {
62209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62210       };
62211     }
62212   }
62213
62214   jresult = result;
62215   return jresult;
62216 }
62217
62218
62219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62221
62222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62223   {
62224     try {
62225       (arg1)->OnKeyInputFocusGained();
62226     } catch (std::out_of_range& e) {
62227       {
62228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62229       };
62230     } catch (std::exception& e) {
62231       {
62232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62233       };
62234     } catch (Dali::DaliException e) {
62235       {
62236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62237       };
62238     } catch (...) {
62239       {
62240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62241       };
62242     }
62243   }
62244
62245 }
62246
62247
62248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62250
62251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62252   {
62253     try {
62254       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62255     } catch (std::out_of_range& e) {
62256       {
62257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62258       };
62259     } catch (std::exception& e) {
62260       {
62261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62262       };
62263     } catch (Dali::DaliException e) {
62264       {
62265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62266       };
62267     } catch (...) {
62268       {
62269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62270       };
62271     }
62272   }
62273
62274 }
62275
62276
62277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62279
62280   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62281   {
62282     try {
62283       (arg1)->OnKeyInputFocusLost();
62284     } catch (std::out_of_range& e) {
62285       {
62286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62287       };
62288     } catch (std::exception& e) {
62289       {
62290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62291       };
62292     } catch (Dali::DaliException e) {
62293       {
62294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62295       };
62296     } catch (...) {
62297       {
62298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62299       };
62300     }
62301   }
62302
62303 }
62304
62305
62306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62308
62309   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62310   {
62311     try {
62312       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62313     } catch (std::out_of_range& e) {
62314       {
62315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62316       };
62317     } catch (std::exception& e) {
62318       {
62319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62320       };
62321     } catch (Dali::DaliException e) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62324       };
62325     } catch (...) {
62326       {
62327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62328       };
62329     }
62330   }
62331
62332 }
62333
62334
62335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62336   void * jresult ;
62337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62338   Dali::Actor arg2 ;
62339   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62340   bool arg4 ;
62341   Dali::Actor *argp2 ;
62342   Dali::Actor result;
62343
62344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62345   argp2 = (Dali::Actor *)jarg2;
62346   if (!argp2) {
62347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62348     return 0;
62349   }
62350   arg2 = *argp2;
62351   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62352   arg4 = jarg4 ? true : false;
62353   {
62354     try {
62355       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62356     } catch (std::out_of_range& e) {
62357       {
62358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62359       };
62360     } catch (std::exception& e) {
62361       {
62362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62363       };
62364     } catch (Dali::DaliException e) {
62365       {
62366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62367       };
62368     } catch (...) {
62369       {
62370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62371       };
62372     }
62373   }
62374
62375   jresult = new Dali::Actor((const Dali::Actor &)result);
62376   return jresult;
62377 }
62378
62379
62380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62381   void * jresult ;
62382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62383   Dali::Actor arg2 ;
62384   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62385   bool arg4 ;
62386   Dali::Actor *argp2 ;
62387   Dali::Actor result;
62388
62389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62390   argp2 = (Dali::Actor *)jarg2;
62391   if (!argp2) {
62392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62393     return 0;
62394   }
62395   arg2 = *argp2;
62396   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62397   arg4 = jarg4 ? true : false;
62398   {
62399     try {
62400       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62401     } catch (std::out_of_range& e) {
62402       {
62403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62404       };
62405     } catch (std::exception& e) {
62406       {
62407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62408       };
62409     } catch (Dali::DaliException e) {
62410       {
62411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62412       };
62413     } catch (...) {
62414       {
62415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62416       };
62417     }
62418   }
62419
62420   jresult = new Dali::Actor((const Dali::Actor &)result);
62421   return jresult;
62422 }
62423
62424
62425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62426   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62427   Dali::Actor arg2 ;
62428   Dali::Actor *argp2 ;
62429
62430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62431   argp2 = (Dali::Actor *)jarg2;
62432   if (!argp2) {
62433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62434     return ;
62435   }
62436   arg2 = *argp2;
62437   {
62438     try {
62439       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62440     } catch (std::out_of_range& e) {
62441       {
62442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62443       };
62444     } catch (std::exception& e) {
62445       {
62446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62447       };
62448     } catch (Dali::DaliException e) {
62449       {
62450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62451       };
62452     } catch (...) {
62453       {
62454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62455       };
62456     }
62457   }
62458
62459 }
62460
62461
62462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62464   Dali::Actor arg2 ;
62465   Dali::Actor *argp2 ;
62466
62467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62468   argp2 = (Dali::Actor *)jarg2;
62469   if (!argp2) {
62470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62471     return ;
62472   }
62473   arg2 = *argp2;
62474   {
62475     try {
62476       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62477     } catch (std::out_of_range& e) {
62478       {
62479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62480       };
62481     } catch (std::exception& e) {
62482       {
62483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62484       };
62485     } catch (Dali::DaliException e) {
62486       {
62487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62488       };
62489     } catch (...) {
62490       {
62491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62492       };
62493     }
62494   }
62495
62496 }
62497
62498
62499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62500   unsigned int jresult ;
62501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62502   bool result;
62503
62504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62505   {
62506     try {
62507       result = (bool)(arg1)->OnKeyboardEnter();
62508     } catch (std::out_of_range& e) {
62509       {
62510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62511       };
62512     } catch (std::exception& e) {
62513       {
62514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62515       };
62516     } catch (Dali::DaliException e) {
62517       {
62518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62519       };
62520     } catch (...) {
62521       {
62522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62523       };
62524     }
62525   }
62526
62527   jresult = result;
62528   return jresult;
62529 }
62530
62531
62532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62533   unsigned int jresult ;
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   bool result;
62536
62537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62538   {
62539     try {
62540       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62541     } catch (std::out_of_range& e) {
62542       {
62543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62544       };
62545     } catch (std::exception& e) {
62546       {
62547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62548       };
62549     } catch (Dali::DaliException e) {
62550       {
62551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62552       };
62553     } catch (...) {
62554       {
62555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62556       };
62557     }
62558   }
62559
62560   jresult = result;
62561   return jresult;
62562 }
62563
62564
62565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62567   Dali::PinchGesture *arg2 = 0 ;
62568
62569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62570   arg2 = (Dali::PinchGesture *)jarg2;
62571   if (!arg2) {
62572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62573     return ;
62574   }
62575   {
62576     try {
62577       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62578     } catch (std::out_of_range& e) {
62579       {
62580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62581       };
62582     } catch (std::exception& e) {
62583       {
62584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62585       };
62586     } catch (Dali::DaliException e) {
62587       {
62588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62589       };
62590     } catch (...) {
62591       {
62592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62593       };
62594     }
62595   }
62596
62597 }
62598
62599
62600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62602   Dali::PinchGesture *arg2 = 0 ;
62603
62604   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62605   arg2 = (Dali::PinchGesture *)jarg2;
62606   if (!arg2) {
62607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62608     return ;
62609   }
62610   {
62611     try {
62612       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62613     } catch (std::out_of_range& e) {
62614       {
62615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62616       };
62617     } catch (std::exception& e) {
62618       {
62619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62620       };
62621     } catch (Dali::DaliException e) {
62622       {
62623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62624       };
62625     } catch (...) {
62626       {
62627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62628       };
62629     }
62630   }
62631
62632 }
62633
62634
62635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62637   Dali::PanGesture *arg2 = 0 ;
62638
62639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62640   arg2 = (Dali::PanGesture *)jarg2;
62641   if (!arg2) {
62642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62643     return ;
62644   }
62645   {
62646     try {
62647       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62648     } catch (std::out_of_range& e) {
62649       {
62650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62651       };
62652     } catch (std::exception& e) {
62653       {
62654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62655       };
62656     } catch (Dali::DaliException e) {
62657       {
62658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62659       };
62660     } catch (...) {
62661       {
62662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62663       };
62664     }
62665   }
62666
62667 }
62668
62669
62670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62672   Dali::PanGesture *arg2 = 0 ;
62673
62674   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62675   arg2 = (Dali::PanGesture *)jarg2;
62676   if (!arg2) {
62677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62678     return ;
62679   }
62680   {
62681     try {
62682       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62683     } catch (std::out_of_range& e) {
62684       {
62685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62686       };
62687     } catch (std::exception& e) {
62688       {
62689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62690       };
62691     } catch (Dali::DaliException e) {
62692       {
62693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62694       };
62695     } catch (...) {
62696       {
62697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62698       };
62699     }
62700   }
62701
62702 }
62703
62704
62705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62707   Dali::TapGesture *arg2 = 0 ;
62708
62709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62710   arg2 = (Dali::TapGesture *)jarg2;
62711   if (!arg2) {
62712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62713     return ;
62714   }
62715   {
62716     try {
62717       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62733       };
62734     }
62735   }
62736
62737 }
62738
62739
62740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62742   Dali::TapGesture *arg2 = 0 ;
62743
62744   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62745   arg2 = (Dali::TapGesture *)jarg2;
62746   if (!arg2) {
62747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62748     return ;
62749   }
62750   {
62751     try {
62752       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62753     } catch (std::out_of_range& e) {
62754       {
62755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62756       };
62757     } catch (std::exception& e) {
62758       {
62759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62760       };
62761     } catch (Dali::DaliException e) {
62762       {
62763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62764       };
62765     } catch (...) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62768       };
62769     }
62770   }
62771
62772 }
62773
62774
62775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62777   Dali::LongPressGesture *arg2 = 0 ;
62778
62779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62780   arg2 = (Dali::LongPressGesture *)jarg2;
62781   if (!arg2) {
62782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62783     return ;
62784   }
62785   {
62786     try {
62787       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62788     } catch (std::out_of_range& e) {
62789       {
62790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62791       };
62792     } catch (std::exception& e) {
62793       {
62794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62795       };
62796     } catch (Dali::DaliException e) {
62797       {
62798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62799       };
62800     } catch (...) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62803       };
62804     }
62805   }
62806
62807 }
62808
62809
62810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62812   Dali::LongPressGesture *arg2 = 0 ;
62813
62814   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62815   arg2 = (Dali::LongPressGesture *)jarg2;
62816   if (!arg2) {
62817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62818     return ;
62819   }
62820   {
62821     try {
62822       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62823     } catch (std::out_of_range& e) {
62824       {
62825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62826       };
62827     } catch (std::exception& e) {
62828       {
62829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62830       };
62831     } catch (Dali::DaliException e) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62838       };
62839     }
62840   }
62841
62842 }
62843
62844
62845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62847   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62848   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62849
62850   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62851   arg2 = (Dali::SlotObserver *)jarg2;
62852   arg3 = (Dali::CallbackBase *)jarg3;
62853   {
62854     try {
62855       (arg1)->SignalConnected(arg2,arg3);
62856     } catch (std::out_of_range& e) {
62857       {
62858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62859       };
62860     } catch (std::exception& e) {
62861       {
62862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62863       };
62864     } catch (Dali::DaliException e) {
62865       {
62866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62867       };
62868     } catch (...) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62871       };
62872     }
62873   }
62874
62875 }
62876
62877
62878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62880   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62881   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62882
62883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62884   arg2 = (Dali::SlotObserver *)jarg2;
62885   arg3 = (Dali::CallbackBase *)jarg3;
62886   {
62887     try {
62888       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62889     } catch (std::out_of_range& e) {
62890       {
62891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62892       };
62893     } catch (std::exception& e) {
62894       {
62895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62896       };
62897     } catch (Dali::DaliException e) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62904       };
62905     }
62906   }
62907
62908 }
62909
62910
62911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62913   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62914   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62915
62916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62917   arg2 = (Dali::SlotObserver *)jarg2;
62918   arg3 = (Dali::CallbackBase *)jarg3;
62919   {
62920     try {
62921       (arg1)->SignalDisconnected(arg2,arg3);
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_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62946   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62947   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62948
62949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62950   arg2 = (Dali::SlotObserver *)jarg2;
62951   arg3 = (Dali::CallbackBase *)jarg3;
62952   {
62953     try {
62954       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62955     } catch (std::out_of_range& e) {
62956       {
62957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62958       };
62959     } catch (std::exception& e) {
62960       {
62961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62962       };
62963     } catch (Dali::DaliException e) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62966       };
62967     } catch (...) {
62968       {
62969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62970       };
62971     }
62972   }
62973
62974 }
62975
62976
62977 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_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) {
62978   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62979   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62980   if (director) {
62981     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, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62982   }
62983 }
62984
62985
62986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62987   void * jresult ;
62988   Dali::Toolkit::Control *arg1 = 0 ;
62989   Dali::Toolkit::Internal::Control *result = 0 ;
62990
62991   arg1 = (Dali::Toolkit::Control *)jarg1;
62992   if (!arg1) {
62993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62994     return 0;
62995   }
62996   {
62997     try {
62998       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62999     } catch (std::out_of_range& e) {
63000       {
63001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (std::exception& e) {
63004       {
63005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (Dali::DaliException e) {
63008       {
63009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63010       };
63011     } catch (...) {
63012       {
63013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63014       };
63015     }
63016   }
63017
63018   jresult = (void *)result;
63019   return jresult;
63020 }
63021
63022
63023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63024   int jresult ;
63025   int result;
63026
63027   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63028   jresult = (int)result;
63029   return jresult;
63030 }
63031
63032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63033   int jresult ;
63034   int result;
63035
63036   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63037   jresult = (int)result;
63038   return jresult;
63039 }
63040
63041
63042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63043   int jresult ;
63044   int result;
63045
63046   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63047   jresult = (int)result;
63048   return jresult;
63049 }
63050
63051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
63052   int jresult ;
63053   int result;
63054
63055   result = (int)Dali::Toolkit::Control::Property::MARGIN;
63056   jresult = (int)result;
63057   return jresult;
63058 }
63059
63060
63061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
63062   int jresult ;
63063   int result;
63064
63065   result = (int)Dali::Toolkit::Control::Property::PADDING;
63066   jresult = (int)result;
63067   return jresult;
63068 }
63069
63070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63071   int jresult ;
63072   int result;
63073
63074   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63075   jresult = (int)result;
63076   return jresult;
63077 }
63078
63079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63080   void * jresult ;
63081   Dali::Toolkit::Control::Property *result = 0 ;
63082
63083   {
63084     try {
63085       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63086     } catch (std::out_of_range& e) {
63087       {
63088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63089       };
63090     } catch (std::exception& e) {
63091       {
63092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63093       };
63094     } catch (Dali::DaliException e) {
63095       {
63096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63097       };
63098     } catch (...) {
63099       {
63100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63101       };
63102     }
63103   }
63104
63105   jresult = (void *)result;
63106   return jresult;
63107 }
63108
63109
63110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63111   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63112
63113   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63114   {
63115     try {
63116       delete arg1;
63117     } catch (std::out_of_range& e) {
63118       {
63119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63120       };
63121     } catch (std::exception& e) {
63122       {
63123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63124       };
63125     } catch (Dali::DaliException e) {
63126       {
63127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63128       };
63129     } catch (...) {
63130       {
63131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63132       };
63133     }
63134   }
63135
63136 }
63137
63138
63139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63140   void * jresult ;
63141   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63142
63143   {
63144     try {
63145       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63146     } catch (std::out_of_range& e) {
63147       {
63148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63149       };
63150     } catch (std::exception& e) {
63151       {
63152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63153       };
63154     } catch (Dali::DaliException e) {
63155       {
63156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63157       };
63158     } catch (...) {
63159       {
63160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63161       };
63162     }
63163   }
63164
63165   jresult = (void *)result;
63166   return jresult;
63167 }
63168
63169
63170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63171   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63172
63173   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63174   {
63175     try {
63176       delete arg1;
63177     } catch (std::out_of_range& e) {
63178       {
63179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63180       };
63181     } catch (std::exception& e) {
63182       {
63183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63184       };
63185     } catch (Dali::DaliException e) {
63186       {
63187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63188       };
63189     } catch (...) {
63190       {
63191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63192       };
63193     }
63194   }
63195
63196 }
63197
63198
63199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63200   void * jresult ;
63201   Dali::Toolkit::Control result;
63202
63203   {
63204     try {
63205       result = Dali::Toolkit::Control::New();
63206     } catch (std::out_of_range& e) {
63207       {
63208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63209       };
63210     } catch (std::exception& e) {
63211       {
63212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63213       };
63214     } catch (Dali::DaliException e) {
63215       {
63216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63217       };
63218     } catch (...) {
63219       {
63220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63221       };
63222     }
63223   }
63224
63225   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63226   return jresult;
63227 }
63228
63229
63230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63231   void * jresult ;
63232   Dali::Toolkit::Control *result = 0 ;
63233
63234   {
63235     try {
63236       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63237     } catch (std::out_of_range& e) {
63238       {
63239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63240       };
63241     } catch (std::exception& e) {
63242       {
63243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63244       };
63245     } catch (Dali::DaliException e) {
63246       {
63247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63248       };
63249     } catch (...) {
63250       {
63251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63252       };
63253     }
63254   }
63255
63256   jresult = (void *)result;
63257   return jresult;
63258 }
63259
63260
63261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63262   void * jresult ;
63263   Dali::Toolkit::Control *arg1 = 0 ;
63264   Dali::Toolkit::Control *result = 0 ;
63265
63266   arg1 = (Dali::Toolkit::Control *)jarg1;
63267   if (!arg1) {
63268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63269     return 0;
63270   }
63271   {
63272     try {
63273       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63274     } catch (std::out_of_range& e) {
63275       {
63276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63277       };
63278     } catch (std::exception& e) {
63279       {
63280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63281       };
63282     } catch (Dali::DaliException e) {
63283       {
63284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63285       };
63286     } catch (...) {
63287       {
63288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63289       };
63290     }
63291   }
63292
63293   jresult = (void *)result;
63294   return jresult;
63295 }
63296
63297
63298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63299   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63300
63301   arg1 = (Dali::Toolkit::Control *)jarg1;
63302   {
63303     try {
63304       delete arg1;
63305     } catch (std::out_of_range& e) {
63306       {
63307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63308       };
63309     } catch (std::exception& e) {
63310       {
63311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63312       };
63313     } catch (Dali::DaliException e) {
63314       {
63315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63316       };
63317     } catch (...) {
63318       {
63319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63320       };
63321     }
63322   }
63323
63324 }
63325
63326
63327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63328   void * jresult ;
63329   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63330   Dali::Toolkit::Control *arg2 = 0 ;
63331   Dali::Toolkit::Control *result = 0 ;
63332
63333   arg1 = (Dali::Toolkit::Control *)jarg1;
63334   arg2 = (Dali::Toolkit::Control *)jarg2;
63335   if (!arg2) {
63336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63337     return 0;
63338   }
63339   {
63340     try {
63341       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63342     } catch (std::out_of_range& e) {
63343       {
63344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63345       };
63346     } catch (std::exception& e) {
63347       {
63348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63349       };
63350     } catch (Dali::DaliException e) {
63351       {
63352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63353       };
63354     } catch (...) {
63355       {
63356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63357       };
63358     }
63359   }
63360
63361   jresult = (void *)result;
63362   return jresult;
63363 }
63364
63365
63366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63367   void * jresult ;
63368   Dali::BaseHandle arg1 ;
63369   Dali::BaseHandle *argp1 ;
63370   Dali::Toolkit::Control result;
63371
63372   argp1 = (Dali::BaseHandle *)jarg1;
63373   if (!argp1) {
63374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63375     return 0;
63376   }
63377   arg1 = *argp1;
63378   {
63379     try {
63380       result = Dali::Toolkit::Control::DownCast(arg1);
63381     } catch (std::out_of_range& e) {
63382       {
63383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63384       };
63385     } catch (std::exception& e) {
63386       {
63387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63388       };
63389     } catch (Dali::DaliException e) {
63390       {
63391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63392       };
63393     } catch (...) {
63394       {
63395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63396       };
63397     }
63398   }
63399
63400   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63401   return jresult;
63402 }
63403
63404
63405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63406   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63407
63408   arg1 = (Dali::Toolkit::Control *)jarg1;
63409   {
63410     try {
63411       (arg1)->SetKeyInputFocus();
63412     } catch (std::out_of_range& e) {
63413       {
63414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63415       };
63416     } catch (std::exception& e) {
63417       {
63418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63419       };
63420     } catch (Dali::DaliException e) {
63421       {
63422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63423       };
63424     } catch (...) {
63425       {
63426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63427       };
63428     }
63429   }
63430
63431 }
63432
63433
63434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63435   unsigned int jresult ;
63436   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63437   bool result;
63438
63439   arg1 = (Dali::Toolkit::Control *)jarg1;
63440   {
63441     try {
63442       result = (bool)(arg1)->HasKeyInputFocus();
63443     } catch (std::out_of_range& e) {
63444       {
63445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63446       };
63447     } catch (std::exception& e) {
63448       {
63449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63450       };
63451     } catch (Dali::DaliException e) {
63452       {
63453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63454       };
63455     } catch (...) {
63456       {
63457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63458       };
63459     }
63460   }
63461
63462   jresult = result;
63463   return jresult;
63464 }
63465
63466
63467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63468   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63469
63470   arg1 = (Dali::Toolkit::Control *)jarg1;
63471   {
63472     try {
63473       (arg1)->ClearKeyInputFocus();
63474     } catch (std::out_of_range& e) {
63475       {
63476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63477       };
63478     } catch (std::exception& e) {
63479       {
63480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63481       };
63482     } catch (Dali::DaliException e) {
63483       {
63484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63485       };
63486     } catch (...) {
63487       {
63488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63489       };
63490     }
63491   }
63492
63493 }
63494
63495
63496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63497   void * jresult ;
63498   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63499   Dali::PinchGestureDetector result;
63500
63501   arg1 = (Dali::Toolkit::Control *)jarg1;
63502   {
63503     try {
63504       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63505     } catch (std::out_of_range& e) {
63506       {
63507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63508       };
63509     } catch (std::exception& e) {
63510       {
63511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63512       };
63513     } catch (Dali::DaliException e) {
63514       {
63515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63516       };
63517     } catch (...) {
63518       {
63519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63520       };
63521     }
63522   }
63523
63524   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63525   return jresult;
63526 }
63527
63528
63529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63530   void * jresult ;
63531   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63532   Dali::PanGestureDetector result;
63533
63534   arg1 = (Dali::Toolkit::Control *)jarg1;
63535   {
63536     try {
63537       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63538     } catch (std::out_of_range& e) {
63539       {
63540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63541       };
63542     } catch (std::exception& e) {
63543       {
63544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63545       };
63546     } catch (Dali::DaliException e) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63553       };
63554     }
63555   }
63556
63557   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63558   return jresult;
63559 }
63560
63561
63562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63563   void * jresult ;
63564   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63565   Dali::TapGestureDetector result;
63566
63567   arg1 = (Dali::Toolkit::Control *)jarg1;
63568   {
63569     try {
63570       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63571     } catch (std::out_of_range& e) {
63572       {
63573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63574       };
63575     } catch (std::exception& e) {
63576       {
63577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63578       };
63579     } catch (Dali::DaliException e) {
63580       {
63581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63582       };
63583     } catch (...) {
63584       {
63585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63586       };
63587     }
63588   }
63589
63590   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63591   return jresult;
63592 }
63593
63594
63595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63596   void * jresult ;
63597   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63598   Dali::LongPressGestureDetector result;
63599
63600   arg1 = (Dali::Toolkit::Control *)jarg1;
63601   {
63602     try {
63603       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63604     } catch (std::out_of_range& e) {
63605       {
63606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63607       };
63608     } catch (std::exception& e) {
63609       {
63610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63611       };
63612     } catch (Dali::DaliException e) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63615       };
63616     } catch (...) {
63617       {
63618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63619       };
63620     }
63621   }
63622
63623   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63624   return jresult;
63625 }
63626
63627
63628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63629   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63630   std::string *arg2 = 0 ;
63631
63632   arg1 = (Dali::Toolkit::Control *)jarg1;
63633   if (!jarg2) {
63634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63635     return ;
63636   }
63637   std::string arg2_str(jarg2);
63638   arg2 = &arg2_str;
63639   {
63640     try {
63641       (arg1)->SetStyleName((std::string const &)*arg2);
63642     } catch (std::out_of_range& e) {
63643       {
63644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63645       };
63646     } catch (std::exception& e) {
63647       {
63648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63649       };
63650     } catch (Dali::DaliException e) {
63651       {
63652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63653       };
63654     } catch (...) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63657       };
63658     }
63659   }
63660
63661
63662   //argout typemap for const std::string&
63663
63664 }
63665
63666
63667 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63668   char * jresult ;
63669   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63670   std::string *result = 0 ;
63671
63672   arg1 = (Dali::Toolkit::Control *)jarg1;
63673   {
63674     try {
63675       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63676     } catch (std::out_of_range& e) {
63677       {
63678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63679       };
63680     } catch (std::exception& e) {
63681       {
63682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63683       };
63684     } catch (Dali::DaliException e) {
63685       {
63686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63687       };
63688     } catch (...) {
63689       {
63690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63691       };
63692     }
63693   }
63694
63695   jresult = SWIG_csharp_string_callback(result->c_str());
63696   return jresult;
63697 }
63698
63699
63700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63701   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63702   Dali::Vector4 *arg2 = 0 ;
63703
63704   arg1 = (Dali::Toolkit::Control *)jarg1;
63705   arg2 = (Dali::Vector4 *)jarg2;
63706   if (!arg2) {
63707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63708     return ;
63709   }
63710   {
63711     try {
63712       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63713     } catch (std::out_of_range& e) {
63714       {
63715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63716       };
63717     } catch (std::exception& e) {
63718       {
63719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63720       };
63721     } catch (Dali::DaliException e) {
63722       {
63723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63724       };
63725     } catch (...) {
63726       {
63727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63728       };
63729     }
63730   }
63731
63732 }
63733
63734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63735   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63736
63737   arg1 = (Dali::Toolkit::Control *)jarg1;
63738   {
63739     try {
63740       (arg1)->ClearBackground();
63741     } catch (std::out_of_range& e) {
63742       {
63743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63744       };
63745     } catch (std::exception& e) {
63746       {
63747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63748       };
63749     } catch (Dali::DaliException e) {
63750       {
63751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63752       };
63753     } catch (...) {
63754       {
63755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63756       };
63757     }
63758   }
63759
63760 }
63761
63762
63763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63764   void * jresult ;
63765   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63766   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63767
63768   arg1 = (Dali::Toolkit::Control *)jarg1;
63769   {
63770     try {
63771       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63772     } catch (std::out_of_range& e) {
63773       {
63774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63775       };
63776     } catch (std::exception& e) {
63777       {
63778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63779       };
63780     } catch (Dali::DaliException e) {
63781       {
63782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63783       };
63784     } catch (...) {
63785       {
63786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63787       };
63788     }
63789   }
63790
63791   jresult = (void *)result;
63792   return jresult;
63793 }
63794
63795
63796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63797   void * jresult ;
63798   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63799   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63800
63801   arg1 = (Dali::Toolkit::Control *)jarg1;
63802   {
63803     try {
63804       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63805     } catch (std::out_of_range& e) {
63806       {
63807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (std::exception& e) {
63810       {
63811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63812       };
63813     } catch (Dali::DaliException e) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63816       };
63817     } catch (...) {
63818       {
63819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63820       };
63821     }
63822   }
63823
63824   jresult = (void *)result;
63825   return jresult;
63826 }
63827
63828
63829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63830   void * jresult ;
63831   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63832   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63833
63834   arg1 = (Dali::Toolkit::Control *)jarg1;
63835   {
63836     try {
63837       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63838     } catch (std::out_of_range& e) {
63839       {
63840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (std::exception& e) {
63843       {
63844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63845       };
63846     } catch (Dali::DaliException e) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63849       };
63850     } catch (...) {
63851       {
63852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63853       };
63854     }
63855   }
63856
63857   jresult = (void *)result;
63858   return jresult;
63859 }
63860
63861
63862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63863   void * jresult ;
63864   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63865   Dali::Toolkit::Control *result = 0 ;
63866
63867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63868   if (!arg1) {
63869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63870     return 0;
63871   }
63872   {
63873     try {
63874       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63875     } catch (std::out_of_range& e) {
63876       {
63877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63878       };
63879     } catch (std::exception& e) {
63880       {
63881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63882       };
63883     } catch (Dali::DaliException e) {
63884       {
63885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63886       };
63887     } catch (...) {
63888       {
63889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63890       };
63891     }
63892   }
63893
63894   jresult = (void *)result;
63895   return jresult;
63896 }
63897
63898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63899 {
63900   int jresult;
63901   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63902   arg1 = (Dali::Toolkit::Control *)jarg1;
63903
63904   if (!arg1) {
63905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63906     return 0;
63907   }
63908
63909   Dali::Property::Index arg2 = 0 ;
63910   arg2 = (Dali::Property::Index)jarg2;
63911
63912   Toolkit::Visual::ResourceStatus result;
63913   {
63914     try {
63915       result = arg1->GetVisualResourceStatus(arg2);
63916     } catch (std::out_of_range& e) {
63917       {
63918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63919       };
63920     } catch (std::exception& e) {
63921       {
63922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63923       };
63924     } catch (...) {
63925       {
63926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63927       };
63928     }
63929   }
63930   jresult = (int)(result);
63931   return jresult;
63932 }
63933
63934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63935 {
63936   void * jresult;
63937   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63938   arg1 = (Dali::Toolkit::Control *)jarg1;
63939
63940   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63941
63942   Dali::Toolkit::TransitionData *arg2 = 0 ;
63943   Dali::Animation result;
63944
63945   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63946   if (!arg2) {
63947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63948     return 0;
63949   }
63950   {
63951     try {
63952       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63953     } catch (std::out_of_range& e) {
63954       {
63955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63956       };
63957     } catch (std::exception& e) {
63958       {
63959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63960       };
63961     } catch (Dali::DaliException e) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63964       };
63965     } catch (...) {
63966       {
63967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63968       };
63969     }
63970   }
63971
63972   jresult = new Dali::Animation((const Dali::Animation &)result);
63973   return jresult;
63974 }
63975
63976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63977 {
63978   Dali::Toolkit::Control arg1;
63979   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63980
63981   if (!argp1) {
63982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63983   }
63984   arg1 = *argp1;
63985
63986   Dali::Property::Index arg2 = 0 ;
63987   arg2 = (Dali::Property::Index)jarg2;
63988
63989   Dali::Property::Index arg3 = 0 ;
63990   arg3 = (Dali::Property::Index)jarg3;
63991
63992   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63993
63994   {
63995     try {
63996       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63997     } catch (std::out_of_range& e) {
63998       {
63999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64000       };
64001     } catch (std::exception& e) {
64002       {
64003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64004       };
64005     } catch (...) {
64006       {
64007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64008       };
64009     }
64010   }
64011
64012
64013 }
64014
64015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64016   void * jresult ;
64017   Dali::Toolkit::Control *arg1 = 0 ;
64018   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
64019
64020   arg1 = (Dali::Toolkit::Control *)jarg1;
64021   if (!arg1) {
64022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64023     return 0;
64024   }
64025   {
64026     try {
64027       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
64028     } catch (std::out_of_range& e) {
64029       {
64030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64031       };
64032     } catch (std::exception& e) {
64033       {
64034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64035       };
64036     } catch (Dali::DaliException e) {
64037       {
64038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64039       };
64040     } catch (...) {
64041       {
64042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64043       };
64044     }
64045   }
64046
64047   jresult = (void *)result;
64048   return jresult;
64049 }
64050
64051
64052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64053   unsigned int jresult ;
64054   Dali::Toolkit::Control *arg1 = 0 ;
64055   bool result;
64056
64057   arg1 = (Dali::Toolkit::Control *)jarg1;
64058   if (!arg1) {
64059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64060     return 0;
64061   }
64062   {
64063     try {
64064       result = (bool)arg1->IsResourceReady();
64065     } catch (std::out_of_range& e) {
64066       {
64067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64068       };
64069     } catch (std::exception& e) {
64070       {
64071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64072       };
64073     } catch (Dali::DaliException e) {
64074       {
64075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64076       };
64077     } catch (...) {
64078       {
64079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64080       };
64081     }
64082   }
64083
64084   jresult = result;
64085   return jresult;
64086 }
64087
64088
64089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64090   void * jresult ;
64091   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64092
64093   {
64094     try {
64095       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
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 = (void *)result;
64116   return jresult;
64117 }
64118
64119
64120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64121   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64122
64123   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64124   {
64125     try {
64126       delete arg1;
64127     } catch (std::out_of_range& e) {
64128       {
64129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64130       };
64131     } catch (std::exception& e) {
64132       {
64133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64134       };
64135     } catch (Dali::DaliException e) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64138       };
64139     } catch (...) {
64140       {
64141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64142       };
64143     }
64144   }
64145
64146 }
64147
64148
64149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64150   void * jresult ;
64151   Dali::Toolkit::KeyInputFocusManager result;
64152
64153   {
64154     try {
64155       result = Dali::Toolkit::KeyInputFocusManager::Get();
64156     } catch (std::out_of_range& e) {
64157       {
64158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64159       };
64160     } catch (std::exception& e) {
64161       {
64162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64163       };
64164     } catch (Dali::DaliException e) {
64165       {
64166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64167       };
64168     } catch (...) {
64169       {
64170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64171       };
64172     }
64173   }
64174
64175   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64176   return jresult;
64177 }
64178
64179
64180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64181   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64182   Dali::Toolkit::Control arg2 ;
64183   Dali::Toolkit::Control *argp2 ;
64184
64185   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64186   argp2 = (Dali::Toolkit::Control *)jarg2;
64187   if (!argp2) {
64188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64189     return ;
64190   }
64191   arg2 = *argp2;
64192   {
64193     try {
64194       (arg1)->SetFocus(arg2);
64195     } catch (std::out_of_range& e) {
64196       {
64197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64198       };
64199     } catch (std::exception& e) {
64200       {
64201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64202       };
64203     } catch (Dali::DaliException e) {
64204       {
64205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64206       };
64207     } catch (...) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64210       };
64211     }
64212   }
64213
64214 }
64215
64216
64217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64218   void * jresult ;
64219   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64220   Dali::Toolkit::Control result;
64221
64222   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64223   {
64224     try {
64225       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64226     } catch (std::out_of_range& e) {
64227       {
64228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64229       };
64230     } catch (std::exception& e) {
64231       {
64232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64233       };
64234     } catch (Dali::DaliException e) {
64235       {
64236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64237       };
64238     } catch (...) {
64239       {
64240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64241       };
64242     }
64243   }
64244
64245   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64246   return jresult;
64247 }
64248
64249
64250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64251   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64252   Dali::Toolkit::Control arg2 ;
64253   Dali::Toolkit::Control *argp2 ;
64254
64255   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64256   argp2 = (Dali::Toolkit::Control *)jarg2;
64257   if (!argp2) {
64258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64259     return ;
64260   }
64261   arg2 = *argp2;
64262   {
64263     try {
64264       (arg1)->RemoveFocus(arg2);
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64272       };
64273     } catch (Dali::DaliException e) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64280       };
64281     }
64282   }
64283
64284 }
64285
64286
64287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64288   void * jresult ;
64289   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64290   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64291
64292   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64293   {
64294     try {
64295       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64296     } catch (std::out_of_range& e) {
64297       {
64298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64299       };
64300     } catch (std::exception& e) {
64301       {
64302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64303       };
64304     } catch (Dali::DaliException e) {
64305       {
64306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64307       };
64308     } catch (...) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64311       };
64312     }
64313   }
64314
64315   jresult = (void *)result;
64316   return jresult;
64317 }
64318
64319
64320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64321   void * jresult ;
64322   Dali::Toolkit::Alignment::Padding *result = 0 ;
64323
64324   {
64325     try {
64326       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64327     } catch (std::out_of_range& e) {
64328       {
64329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64330       };
64331     } catch (std::exception& e) {
64332       {
64333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64334       };
64335     } catch (Dali::DaliException e) {
64336       {
64337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64338       };
64339     } catch (...) {
64340       {
64341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64342       };
64343     }
64344   }
64345
64346   jresult = (void *)result;
64347   return jresult;
64348 }
64349
64350
64351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64352   void * jresult ;
64353   float arg1 ;
64354   float arg2 ;
64355   float arg3 ;
64356   float arg4 ;
64357   Dali::Toolkit::Alignment::Padding *result = 0 ;
64358
64359   arg1 = (float)jarg1;
64360   arg2 = (float)jarg2;
64361   arg3 = (float)jarg3;
64362   arg4 = (float)jarg4;
64363   {
64364     try {
64365       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
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 = (void *)result;
64386   return jresult;
64387 }
64388
64389
64390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64391   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64392   float arg2 ;
64393
64394   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64395   arg2 = (float)jarg2;
64396   if (arg1) (arg1)->left = arg2;
64397 }
64398
64399
64400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64401   float jresult ;
64402   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64403   float result;
64404
64405   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64406   result = (float) ((arg1)->left);
64407   jresult = result;
64408   return jresult;
64409 }
64410
64411
64412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64413   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64414   float arg2 ;
64415
64416   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64417   arg2 = (float)jarg2;
64418   if (arg1) (arg1)->right = arg2;
64419 }
64420
64421
64422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64423   float jresult ;
64424   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64425   float result;
64426
64427   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64428   result = (float) ((arg1)->right);
64429   jresult = result;
64430   return jresult;
64431 }
64432
64433
64434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64435   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64436   float arg2 ;
64437
64438   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64439   arg2 = (float)jarg2;
64440   if (arg1) (arg1)->top = arg2;
64441 }
64442
64443
64444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64445   float jresult ;
64446   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64447   float result;
64448
64449   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64450   result = (float) ((arg1)->top);
64451   jresult = result;
64452   return jresult;
64453 }
64454
64455
64456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64457   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64458   float arg2 ;
64459
64460   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64461   arg2 = (float)jarg2;
64462   if (arg1) (arg1)->bottom = arg2;
64463 }
64464
64465
64466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64467   float jresult ;
64468   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64469   float result;
64470
64471   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64472   result = (float) ((arg1)->bottom);
64473   jresult = result;
64474   return jresult;
64475 }
64476
64477
64478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64479   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64480
64481   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64482   {
64483     try {
64484       delete arg1;
64485     } catch (std::out_of_range& e) {
64486       {
64487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64488       };
64489     } catch (std::exception& e) {
64490       {
64491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64492       };
64493     } catch (Dali::DaliException e) {
64494       {
64495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64496       };
64497     } catch (...) {
64498       {
64499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64500       };
64501     }
64502   }
64503
64504 }
64505
64506
64507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64508   void * jresult ;
64509   Dali::Toolkit::Alignment *result = 0 ;
64510
64511   {
64512     try {
64513       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64514     } catch (std::out_of_range& e) {
64515       {
64516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64517       };
64518     } catch (std::exception& e) {
64519       {
64520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64521       };
64522     } catch (Dali::DaliException e) {
64523       {
64524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64525       };
64526     } catch (...) {
64527       {
64528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64529       };
64530     }
64531   }
64532
64533   jresult = (void *)result;
64534   return jresult;
64535 }
64536
64537
64538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64539   void * jresult ;
64540   Dali::Toolkit::Alignment::Type arg1 ;
64541   Dali::Toolkit::Alignment::Type arg2 ;
64542   Dali::Toolkit::Alignment result;
64543
64544   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64545   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64546   {
64547     try {
64548       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64549     } catch (std::out_of_range& e) {
64550       {
64551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64552       };
64553     } catch (std::exception& e) {
64554       {
64555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64556       };
64557     } catch (Dali::DaliException e) {
64558       {
64559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64560       };
64561     } catch (...) {
64562       {
64563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64564       };
64565     }
64566   }
64567
64568   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64569   return jresult;
64570 }
64571
64572
64573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64574   void * jresult ;
64575   Dali::Toolkit::Alignment::Type arg1 ;
64576   Dali::Toolkit::Alignment result;
64577
64578   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64579   {
64580     try {
64581       result = Dali::Toolkit::Alignment::New(arg1);
64582     } catch (std::out_of_range& e) {
64583       {
64584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64585       };
64586     } catch (std::exception& e) {
64587       {
64588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64589       };
64590     } catch (Dali::DaliException e) {
64591       {
64592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64593       };
64594     } catch (...) {
64595       {
64596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64597       };
64598     }
64599   }
64600
64601   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64602   return jresult;
64603 }
64604
64605
64606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64607   void * jresult ;
64608   Dali::Toolkit::Alignment result;
64609
64610   {
64611     try {
64612       result = Dali::Toolkit::Alignment::New();
64613     } catch (std::out_of_range& e) {
64614       {
64615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64616       };
64617     } catch (std::exception& e) {
64618       {
64619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64620       };
64621     } catch (Dali::DaliException e) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64624       };
64625     } catch (...) {
64626       {
64627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64628       };
64629     }
64630   }
64631
64632   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64633   return jresult;
64634 }
64635
64636
64637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64638   void * jresult ;
64639   Dali::Toolkit::Alignment *arg1 = 0 ;
64640   Dali::Toolkit::Alignment *result = 0 ;
64641
64642   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64643   if (!arg1) {
64644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64645     return 0;
64646   }
64647   {
64648     try {
64649       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64650     } catch (std::out_of_range& e) {
64651       {
64652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64653       };
64654     } catch (std::exception& e) {
64655       {
64656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (Dali::DaliException e) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64661       };
64662     } catch (...) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64665       };
64666     }
64667   }
64668
64669   jresult = (void *)result;
64670   return jresult;
64671 }
64672
64673
64674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64676
64677   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64678   {
64679     try {
64680       delete arg1;
64681     } catch (std::out_of_range& e) {
64682       {
64683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64684       };
64685     } catch (std::exception& e) {
64686       {
64687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64688       };
64689     } catch (Dali::DaliException e) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64692       };
64693     } catch (...) {
64694       {
64695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64696       };
64697     }
64698   }
64699
64700 }
64701
64702
64703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64704   void * jresult ;
64705   Dali::BaseHandle arg1 ;
64706   Dali::BaseHandle *argp1 ;
64707   Dali::Toolkit::Alignment result;
64708
64709   argp1 = (Dali::BaseHandle *)jarg1;
64710   if (!argp1) {
64711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64712     return 0;
64713   }
64714   arg1 = *argp1;
64715   {
64716     try {
64717       result = Dali::Toolkit::Alignment::DownCast(arg1);
64718     } catch (std::out_of_range& e) {
64719       {
64720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64721       };
64722     } catch (std::exception& e) {
64723       {
64724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64725       };
64726     } catch (Dali::DaliException e) {
64727       {
64728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64729       };
64730     } catch (...) {
64731       {
64732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64733       };
64734     }
64735   }
64736
64737   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64738   return jresult;
64739 }
64740
64741
64742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64743   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64744   Dali::Toolkit::Alignment::Type arg2 ;
64745
64746   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64747   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64748   {
64749     try {
64750       (arg1)->SetAlignmentType(arg2);
64751     } catch (std::out_of_range& e) {
64752       {
64753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64754       };
64755     } catch (std::exception& e) {
64756       {
64757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64758       };
64759     } catch (Dali::DaliException e) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64762       };
64763     } catch (...) {
64764       {
64765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64766       };
64767     }
64768   }
64769
64770 }
64771
64772
64773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64774   int jresult ;
64775   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64776   Dali::Toolkit::Alignment::Type result;
64777
64778   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64779   {
64780     try {
64781       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64782     } catch (std::out_of_range& e) {
64783       {
64784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64785       };
64786     } catch (std::exception& e) {
64787       {
64788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64789       };
64790     } catch (Dali::DaliException e) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64793       };
64794     } catch (...) {
64795       {
64796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64797       };
64798     }
64799   }
64800
64801   jresult = (int)result;
64802   return jresult;
64803 }
64804
64805
64806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64807   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64808   Dali::Toolkit::Alignment::Scaling arg2 ;
64809
64810   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64811   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64812   {
64813     try {
64814       (arg1)->SetScaling(arg2);
64815     } catch (std::out_of_range& e) {
64816       {
64817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64818       };
64819     } catch (std::exception& e) {
64820       {
64821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64822       };
64823     } catch (Dali::DaliException e) {
64824       {
64825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64826       };
64827     } catch (...) {
64828       {
64829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64830       };
64831     }
64832   }
64833
64834 }
64835
64836
64837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64838   int jresult ;
64839   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64840   Dali::Toolkit::Alignment::Scaling result;
64841
64842   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64843   {
64844     try {
64845       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64846     } catch (std::out_of_range& e) {
64847       {
64848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64849       };
64850     } catch (std::exception& e) {
64851       {
64852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64853       };
64854     } catch (Dali::DaliException e) {
64855       {
64856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64857       };
64858     } catch (...) {
64859       {
64860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64861       };
64862     }
64863   }
64864
64865   jresult = (int)result;
64866   return jresult;
64867 }
64868
64869
64870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64871   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64872   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64873
64874   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64875   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64876   if (!arg2) {
64877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64878     return ;
64879   }
64880   {
64881     try {
64882       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64883     } catch (std::out_of_range& e) {
64884       {
64885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64886       };
64887     } catch (std::exception& e) {
64888       {
64889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64890       };
64891     } catch (Dali::DaliException e) {
64892       {
64893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64894       };
64895     } catch (...) {
64896       {
64897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64898       };
64899     }
64900   }
64901
64902 }
64903
64904
64905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64906   void * jresult ;
64907   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64908   Dali::Toolkit::Alignment::Padding *result = 0 ;
64909
64910   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64911   {
64912     try {
64913       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64914     } catch (std::out_of_range& e) {
64915       {
64916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64917       };
64918     } catch (std::exception& e) {
64919       {
64920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64921       };
64922     } catch (Dali::DaliException e) {
64923       {
64924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64925       };
64926     } catch (...) {
64927       {
64928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64929       };
64930     }
64931   }
64932
64933   jresult = (void *)result;
64934   return jresult;
64935 }
64936
64937
64938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64939   void * jresult ;
64940   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64941   Dali::Toolkit::Alignment *arg2 = 0 ;
64942   Dali::Toolkit::Alignment *result = 0 ;
64943
64944   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64945   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64946   if (!arg2) {
64947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64948     return 0;
64949   }
64950   {
64951     try {
64952       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64953     } catch (std::out_of_range& e) {
64954       {
64955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64956       };
64957     } catch (std::exception& e) {
64958       {
64959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64960       };
64961     } catch (Dali::DaliException e) {
64962       {
64963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64964       };
64965     } catch (...) {
64966       {
64967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64968       };
64969     }
64970   }
64971
64972   jresult = (void *)result;
64973   return jresult;
64974 }
64975
64976
64977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64978   int jresult ;
64979   int result;
64980
64981   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64982   jresult = (int)result;
64983   return jresult;
64984 }
64985
64986
64987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64988   int jresult ;
64989   int result;
64990
64991   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64992   jresult = (int)result;
64993   return jresult;
64994 }
64995
64996
64997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64998   int jresult ;
64999   int result;
65000
65001   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65002   jresult = (int)result;
65003   return jresult;
65004 }
65005
65006
65007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65008   int jresult ;
65009   int result;
65010
65011   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65012   jresult = (int)result;
65013   return jresult;
65014 }
65015
65016
65017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65018   int jresult ;
65019   int result;
65020
65021   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65022   jresult = (int)result;
65023   return jresult;
65024 }
65025
65026
65027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65028   int jresult ;
65029   int result;
65030
65031   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65032   jresult = (int)result;
65033   return jresult;
65034 }
65035
65036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65037   int jresult ;
65038   int result;
65039
65040   result = (int)Dali::Toolkit::Button::Property::LABEL;
65041   jresult = (int)result;
65042   return jresult;
65043 }
65044
65045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65046   void * jresult ;
65047   Dali::Toolkit::Button::Property *result = 0 ;
65048
65049   {
65050     try {
65051       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65052     } catch (std::out_of_range& e) {
65053       {
65054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65055       };
65056     } catch (std::exception& e) {
65057       {
65058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65059       };
65060     } catch (Dali::DaliException e) {
65061       {
65062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65063       };
65064     } catch (...) {
65065       {
65066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65067       };
65068     }
65069   }
65070
65071   jresult = (void *)result;
65072   return jresult;
65073 }
65074
65075
65076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65077   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65078
65079   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65080   {
65081     try {
65082       delete arg1;
65083     } catch (std::out_of_range& e) {
65084       {
65085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65086       };
65087     } catch (std::exception& e) {
65088       {
65089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65090       };
65091     } catch (Dali::DaliException e) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65094       };
65095     } catch (...) {
65096       {
65097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65098       };
65099     }
65100   }
65101
65102 }
65103
65104
65105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65106   void * jresult ;
65107   Dali::Toolkit::Button *result = 0 ;
65108
65109   {
65110     try {
65111       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65112     } catch (std::out_of_range& e) {
65113       {
65114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65115       };
65116     } catch (std::exception& e) {
65117       {
65118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65119       };
65120     } catch (Dali::DaliException e) {
65121       {
65122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65123       };
65124     } catch (...) {
65125       {
65126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65127       };
65128     }
65129   }
65130
65131   jresult = (void *)result;
65132   return jresult;
65133 }
65134
65135
65136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65137   void * jresult ;
65138   Dali::Toolkit::Button *arg1 = 0 ;
65139   Dali::Toolkit::Button *result = 0 ;
65140
65141   arg1 = (Dali::Toolkit::Button *)jarg1;
65142   if (!arg1) {
65143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65144     return 0;
65145   }
65146   {
65147     try {
65148       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65149     } catch (std::out_of_range& e) {
65150       {
65151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65152       };
65153     } catch (std::exception& e) {
65154       {
65155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65156       };
65157     } catch (Dali::DaliException e) {
65158       {
65159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65160       };
65161     } catch (...) {
65162       {
65163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65164       };
65165     }
65166   }
65167
65168   jresult = (void *)result;
65169   return jresult;
65170 }
65171
65172
65173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65174   void * jresult ;
65175   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65176   Dali::Toolkit::Button *arg2 = 0 ;
65177   Dali::Toolkit::Button *result = 0 ;
65178
65179   arg1 = (Dali::Toolkit::Button *)jarg1;
65180   arg2 = (Dali::Toolkit::Button *)jarg2;
65181   if (!arg2) {
65182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65183     return 0;
65184   }
65185   {
65186     try {
65187       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65188     } catch (std::out_of_range& e) {
65189       {
65190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65191       };
65192     } catch (std::exception& e) {
65193       {
65194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (Dali::DaliException e) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65199       };
65200     } catch (...) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65203       };
65204     }
65205   }
65206
65207   jresult = (void *)result;
65208   return jresult;
65209 }
65210
65211
65212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65213   void * jresult ;
65214   Dali::BaseHandle arg1 ;
65215   Dali::BaseHandle *argp1 ;
65216   Dali::Toolkit::Button result;
65217
65218   argp1 = (Dali::BaseHandle *)jarg1;
65219   if (!argp1) {
65220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65221     return 0;
65222   }
65223   arg1 = *argp1;
65224   {
65225     try {
65226       result = Dali::Toolkit::Button::DownCast(arg1);
65227     } catch (std::out_of_range& e) {
65228       {
65229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (std::exception& e) {
65232       {
65233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65234       };
65235     } catch (Dali::DaliException e) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65238       };
65239     } catch (...) {
65240       {
65241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65242       };
65243     }
65244   }
65245
65246   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65247   return jresult;
65248 }
65249
65250
65251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65252   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65253
65254   arg1 = (Dali::Toolkit::Button *)jarg1;
65255   {
65256     try {
65257       delete arg1;
65258     } catch (std::out_of_range& e) {
65259       {
65260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65261       };
65262     } catch (std::exception& e) {
65263       {
65264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65265       };
65266     } catch (Dali::DaliException e) {
65267       {
65268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65269       };
65270     } catch (...) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65273       };
65274     }
65275   }
65276
65277 }
65278
65279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65280   void * jresult ;
65281   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65282   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65283
65284   arg1 = (Dali::Toolkit::Button *)jarg1;
65285   {
65286     try {
65287       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65288     } catch (std::out_of_range& e) {
65289       {
65290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65291       };
65292     } catch (std::exception& e) {
65293       {
65294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65295       };
65296     } catch (Dali::DaliException e) {
65297       {
65298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65299       };
65300     } catch (...) {
65301       {
65302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65303       };
65304     }
65305   }
65306
65307   jresult = (void *)result;
65308   return jresult;
65309 }
65310
65311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65312   void * jresult ;
65313   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65314   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65315
65316   arg1 = (Dali::Toolkit::Button *)jarg1;
65317   {
65318     try {
65319       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65320     } catch (std::out_of_range& e) {
65321       {
65322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65323       };
65324     } catch (std::exception& e) {
65325       {
65326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65327       };
65328     } catch (Dali::DaliException e) {
65329       {
65330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65331       };
65332     } catch (...) {
65333       {
65334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65335       };
65336     }
65337   }
65338
65339   jresult = (void *)result;
65340   return jresult;
65341 }
65342
65343
65344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65345   void * jresult ;
65346   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65347   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65348
65349   arg1 = (Dali::Toolkit::Button *)jarg1;
65350   {
65351     try {
65352       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65353     } catch (std::out_of_range& e) {
65354       {
65355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65356       };
65357     } catch (std::exception& e) {
65358       {
65359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65360       };
65361     } catch (Dali::DaliException e) {
65362       {
65363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65364       };
65365     } catch (...) {
65366       {
65367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65368       };
65369     }
65370   }
65371
65372   jresult = (void *)result;
65373   return jresult;
65374 }
65375
65376
65377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65378   void * jresult ;
65379   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65380   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65381
65382   arg1 = (Dali::Toolkit::Button *)jarg1;
65383   {
65384     try {
65385       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65386     } catch (std::out_of_range& e) {
65387       {
65388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65389       };
65390     } catch (std::exception& e) {
65391       {
65392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65393       };
65394     } catch (Dali::DaliException e) {
65395       {
65396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65397       };
65398     } catch (...) {
65399       {
65400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65401       };
65402     }
65403   }
65404
65405   jresult = (void *)result;
65406   return jresult;
65407 }
65408
65409
65410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65411   void * jresult ;
65412   Dali::Toolkit::CheckBoxButton *result = 0 ;
65413
65414   {
65415     try {
65416       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65417     } catch (std::out_of_range& e) {
65418       {
65419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65420       };
65421     } catch (std::exception& e) {
65422       {
65423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65424       };
65425     } catch (Dali::DaliException e) {
65426       {
65427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65428       };
65429     } catch (...) {
65430       {
65431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65432       };
65433     }
65434   }
65435
65436   jresult = (void *)result;
65437   return jresult;
65438 }
65439
65440
65441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65442   void * jresult ;
65443   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65444   Dali::Toolkit::CheckBoxButton *result = 0 ;
65445
65446   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65447   if (!arg1) {
65448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65449     return 0;
65450   }
65451   {
65452     try {
65453       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65454     } catch (std::out_of_range& e) {
65455       {
65456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65457       };
65458     } catch (std::exception& e) {
65459       {
65460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65461       };
65462     } catch (Dali::DaliException e) {
65463       {
65464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65465       };
65466     } catch (...) {
65467       {
65468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65469       };
65470     }
65471   }
65472
65473   jresult = (void *)result;
65474   return jresult;
65475 }
65476
65477
65478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65479   void * jresult ;
65480   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65481   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65482   Dali::Toolkit::CheckBoxButton *result = 0 ;
65483
65484   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65485   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65486   if (!arg2) {
65487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65488     return 0;
65489   }
65490   {
65491     try {
65492       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65493     } catch (std::out_of_range& e) {
65494       {
65495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65496       };
65497     } catch (std::exception& e) {
65498       {
65499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65500       };
65501     } catch (Dali::DaliException e) {
65502       {
65503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65504       };
65505     } catch (...) {
65506       {
65507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65508       };
65509     }
65510   }
65511
65512   jresult = (void *)result;
65513   return jresult;
65514 }
65515
65516
65517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65518   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65519
65520   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65521   {
65522     try {
65523       delete arg1;
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65531       };
65532     } catch (Dali::DaliException e) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65535       };
65536     } catch (...) {
65537       {
65538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65539       };
65540     }
65541   }
65542
65543 }
65544
65545
65546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65547   void * jresult ;
65548   Dali::Toolkit::CheckBoxButton result;
65549
65550   {
65551     try {
65552       result = Dali::Toolkit::CheckBoxButton::New();
65553     } catch (std::out_of_range& e) {
65554       {
65555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65556       };
65557     } catch (std::exception& e) {
65558       {
65559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65560       };
65561     } catch (Dali::DaliException e) {
65562       {
65563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65564       };
65565     } catch (...) {
65566       {
65567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65568       };
65569     }
65570   }
65571
65572   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65573   return jresult;
65574 }
65575
65576
65577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65578   void * jresult ;
65579   Dali::BaseHandle arg1 ;
65580   Dali::BaseHandle *argp1 ;
65581   Dali::Toolkit::CheckBoxButton result;
65582
65583   argp1 = (Dali::BaseHandle *)jarg1;
65584   if (!argp1) {
65585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65586     return 0;
65587   }
65588   arg1 = *argp1;
65589   {
65590     try {
65591       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65592     } catch (std::out_of_range& e) {
65593       {
65594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65595       };
65596     } catch (std::exception& e) {
65597       {
65598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65599       };
65600     } catch (Dali::DaliException e) {
65601       {
65602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65603       };
65604     } catch (...) {
65605       {
65606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65607       };
65608     }
65609   }
65610
65611   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65612   return jresult;
65613 }
65614
65615
65616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65617   int jresult ;
65618   int result;
65619
65620   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65621   jresult = (int)result;
65622   return jresult;
65623 }
65624
65625
65626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65627   int jresult ;
65628   int result;
65629
65630   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65631   jresult = (int)result;
65632   return jresult;
65633 }
65634
65635
65636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65637   void * jresult ;
65638   Dali::Toolkit::PushButton::Property *result = 0 ;
65639
65640   {
65641     try {
65642       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65643     } catch (std::out_of_range& e) {
65644       {
65645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65646       };
65647     } catch (std::exception& e) {
65648       {
65649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65650       };
65651     } catch (Dali::DaliException e) {
65652       {
65653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65654       };
65655     } catch (...) {
65656       {
65657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65658       };
65659     }
65660   }
65661
65662   jresult = (void *)result;
65663   return jresult;
65664 }
65665
65666
65667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65668   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65669
65670   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65671   {
65672     try {
65673       delete arg1;
65674     } catch (std::out_of_range& e) {
65675       {
65676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65677       };
65678     } catch (std::exception& e) {
65679       {
65680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65681       };
65682     } catch (Dali::DaliException e) {
65683       {
65684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65685       };
65686     } catch (...) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65689       };
65690     }
65691   }
65692
65693 }
65694
65695
65696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65697   void * jresult ;
65698   Dali::Toolkit::PushButton *result = 0 ;
65699
65700   {
65701     try {
65702       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (Dali::DaliException e) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65714       };
65715     } catch (...) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65718       };
65719     }
65720   }
65721
65722   jresult = (void *)result;
65723   return jresult;
65724 }
65725
65726
65727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65728   void * jresult ;
65729   Dali::Toolkit::PushButton *arg1 = 0 ;
65730   Dali::Toolkit::PushButton *result = 0 ;
65731
65732   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65733   if (!arg1) {
65734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65735     return 0;
65736   }
65737   {
65738     try {
65739       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65740     } catch (std::out_of_range& e) {
65741       {
65742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65743       };
65744     } catch (std::exception& e) {
65745       {
65746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65747       };
65748     } catch (Dali::DaliException e) {
65749       {
65750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65751       };
65752     } catch (...) {
65753       {
65754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65755       };
65756     }
65757   }
65758
65759   jresult = (void *)result;
65760   return jresult;
65761 }
65762
65763
65764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65765   void * jresult ;
65766   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65767   Dali::Toolkit::PushButton *arg2 = 0 ;
65768   Dali::Toolkit::PushButton *result = 0 ;
65769
65770   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65771   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65772   if (!arg2) {
65773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65774     return 0;
65775   }
65776   {
65777     try {
65778       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65779     } catch (std::out_of_range& e) {
65780       {
65781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65782       };
65783     } catch (std::exception& e) {
65784       {
65785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65786       };
65787     } catch (Dali::DaliException e) {
65788       {
65789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65790       };
65791     } catch (...) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65794       };
65795     }
65796   }
65797
65798   jresult = (void *)result;
65799   return jresult;
65800 }
65801
65802
65803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65804   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65805
65806   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65807   {
65808     try {
65809       delete arg1;
65810     } catch (std::out_of_range& e) {
65811       {
65812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65813       };
65814     } catch (std::exception& e) {
65815       {
65816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65817       };
65818     } catch (Dali::DaliException e) {
65819       {
65820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65821       };
65822     } catch (...) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65825       };
65826     }
65827   }
65828
65829 }
65830
65831
65832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65833   void * jresult ;
65834   Dali::Toolkit::PushButton result;
65835
65836   {
65837     try {
65838       result = Dali::Toolkit::PushButton::New();
65839     } catch (std::out_of_range& e) {
65840       {
65841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65842       };
65843     } catch (std::exception& e) {
65844       {
65845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65846       };
65847     } catch (Dali::DaliException e) {
65848       {
65849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65850       };
65851     } catch (...) {
65852       {
65853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65854       };
65855     }
65856   }
65857
65858   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65859   return jresult;
65860 }
65861
65862
65863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65864   void * jresult ;
65865   Dali::BaseHandle arg1 ;
65866   Dali::BaseHandle *argp1 ;
65867   Dali::Toolkit::PushButton result;
65868
65869   argp1 = (Dali::BaseHandle *)jarg1;
65870   if (!argp1) {
65871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65872     return 0;
65873   }
65874   arg1 = *argp1;
65875   {
65876     try {
65877       result = Dali::Toolkit::PushButton::DownCast(arg1);
65878     } catch (std::out_of_range& e) {
65879       {
65880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65881       };
65882     } catch (std::exception& e) {
65883       {
65884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65885       };
65886     } catch (Dali::DaliException e) {
65887       {
65888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65889       };
65890     } catch (...) {
65891       {
65892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65893       };
65894     }
65895   }
65896
65897   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65898   return jresult;
65899 }
65900
65901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65902   void * jresult ;
65903   Dali::Toolkit::RadioButton *result = 0 ;
65904
65905   {
65906     try {
65907       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65908     } catch (std::out_of_range& e) {
65909       {
65910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (std::exception& e) {
65913       {
65914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65915       };
65916     } catch (Dali::DaliException e) {
65917       {
65918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65919       };
65920     } catch (...) {
65921       {
65922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65923       };
65924     }
65925   }
65926
65927   jresult = (void *)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65933   void * jresult ;
65934   Dali::Toolkit::RadioButton *arg1 = 0 ;
65935   Dali::Toolkit::RadioButton *result = 0 ;
65936
65937   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65938   if (!arg1) {
65939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65940     return 0;
65941   }
65942   {
65943     try {
65944       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65945     } catch (std::out_of_range& e) {
65946       {
65947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65948       };
65949     } catch (std::exception& e) {
65950       {
65951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65952       };
65953     } catch (Dali::DaliException e) {
65954       {
65955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65956       };
65957     } catch (...) {
65958       {
65959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65960       };
65961     }
65962   }
65963
65964   jresult = (void *)result;
65965   return jresult;
65966 }
65967
65968
65969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65970   void * jresult ;
65971   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65972   Dali::Toolkit::RadioButton *arg2 = 0 ;
65973   Dali::Toolkit::RadioButton *result = 0 ;
65974
65975   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65976   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65977   if (!arg2) {
65978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65979     return 0;
65980   }
65981   {
65982     try {
65983       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65984     } catch (std::out_of_range& e) {
65985       {
65986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65987       };
65988     } catch (std::exception& e) {
65989       {
65990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65991       };
65992     } catch (Dali::DaliException e) {
65993       {
65994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65995       };
65996     } catch (...) {
65997       {
65998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65999       };
66000     }
66001   }
66002
66003   jresult = (void *)result;
66004   return jresult;
66005 }
66006
66007
66008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66009   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66010
66011   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66012   {
66013     try {
66014       delete arg1;
66015     } catch (std::out_of_range& e) {
66016       {
66017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66018       };
66019     } catch (std::exception& e) {
66020       {
66021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66022       };
66023     } catch (Dali::DaliException e) {
66024       {
66025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66026       };
66027     } catch (...) {
66028       {
66029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66030       };
66031     }
66032   }
66033
66034 }
66035
66036
66037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66038   void * jresult ;
66039   Dali::Toolkit::RadioButton result;
66040
66041   {
66042     try {
66043       result = Dali::Toolkit::RadioButton::New();
66044     } catch (std::out_of_range& e) {
66045       {
66046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66047       };
66048     } catch (std::exception& e) {
66049       {
66050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66051       };
66052     } catch (Dali::DaliException e) {
66053       {
66054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66055       };
66056     } catch (...) {
66057       {
66058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66059       };
66060     }
66061   }
66062
66063   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66064   return jresult;
66065 }
66066
66067
66068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66069   void * jresult ;
66070   std::string *arg1 = 0 ;
66071   Dali::Toolkit::RadioButton result;
66072
66073   if (!jarg1) {
66074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66075     return 0;
66076   }
66077   std::string arg1_str(jarg1);
66078   arg1 = &arg1_str;
66079   {
66080     try {
66081       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66082     } catch (std::out_of_range& e) {
66083       {
66084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66085       };
66086     } catch (std::exception& e) {
66087       {
66088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66089       };
66090     } catch (Dali::DaliException e) {
66091       {
66092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66093       };
66094     } catch (...) {
66095       {
66096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66097       };
66098     }
66099   }
66100
66101   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66102
66103   //argout typemap for const std::string&
66104
66105   return jresult;
66106 }
66107
66108
66109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66110   void * jresult ;
66111   Dali::BaseHandle arg1 ;
66112   Dali::BaseHandle *argp1 ;
66113   Dali::Toolkit::RadioButton result;
66114
66115   argp1 = (Dali::BaseHandle *)jarg1;
66116   if (!argp1) {
66117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66118     return 0;
66119   }
66120   arg1 = *argp1;
66121   {
66122     try {
66123       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66124     } catch (std::out_of_range& e) {
66125       {
66126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66127       };
66128     } catch (std::exception& e) {
66129       {
66130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66131       };
66132     } catch (Dali::DaliException e) {
66133       {
66134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66135       };
66136     } catch (...) {
66137       {
66138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66139       };
66140     }
66141   }
66142
66143   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66144   return jresult;
66145 }
66146
66147
66148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66149   int jresult ;
66150   int result;
66151
66152   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66153   jresult = (int)result;
66154   return jresult;
66155 }
66156
66157
66158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66159   int jresult ;
66160   int result;
66161
66162   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66163   jresult = (int)result;
66164   return jresult;
66165 }
66166
66167
66168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66169   int jresult ;
66170   int result;
66171
66172   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66173   jresult = (int)result;
66174   return jresult;
66175 }
66176
66177
66178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66179   int jresult ;
66180   int result;
66181
66182   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66183   jresult = (int)result;
66184   return jresult;
66185 }
66186
66187
66188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66189   int jresult ;
66190   int result;
66191
66192   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66193   jresult = (int)result;
66194   return jresult;
66195 }
66196
66197
66198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66199   int jresult ;
66200   int result;
66201
66202   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66203   jresult = (int)result;
66204   return jresult;
66205 }
66206
66207
66208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66209   void * jresult ;
66210   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66211
66212   {
66213     try {
66214       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
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 = (void *)result;
66235   return jresult;
66236 }
66237
66238
66239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66240   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66241
66242   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66243   {
66244     try {
66245       delete arg1;
66246     } catch (std::out_of_range& e) {
66247       {
66248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66249       };
66250     } catch (std::exception& e) {
66251       {
66252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66253       };
66254     } catch (Dali::DaliException e) {
66255       {
66256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66257       };
66258     } catch (...) {
66259       {
66260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66261       };
66262     }
66263   }
66264
66265 }
66266
66267
66268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66269   int jresult ;
66270   int result;
66271
66272   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66273   jresult = (int)result;
66274   return jresult;
66275 }
66276
66277
66278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66279   int jresult ;
66280   int result;
66281
66282   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66283   jresult = (int)result;
66284   return jresult;
66285 }
66286
66287
66288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66289   int jresult ;
66290   int result;
66291
66292   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66293   jresult = (int)result;
66294   return jresult;
66295 }
66296
66297
66298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66299   void * jresult ;
66300   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66301
66302   {
66303     try {
66304       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66305     } catch (std::out_of_range& e) {
66306       {
66307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66308       };
66309     } catch (std::exception& e) {
66310       {
66311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66312       };
66313     } catch (Dali::DaliException e) {
66314       {
66315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66316       };
66317     } catch (...) {
66318       {
66319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66320       };
66321     }
66322   }
66323
66324   jresult = (void *)result;
66325   return jresult;
66326 }
66327
66328
66329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66330   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66331
66332   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66333   {
66334     try {
66335       delete arg1;
66336     } catch (std::out_of_range& e) {
66337       {
66338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66339       };
66340     } catch (std::exception& e) {
66341       {
66342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66343       };
66344     } catch (Dali::DaliException e) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66347       };
66348     } catch (...) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66351       };
66352     }
66353   }
66354
66355 }
66356
66357
66358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66359   void * jresult ;
66360   Dali::Toolkit::FlexContainer *result = 0 ;
66361
66362   {
66363     try {
66364       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66365     } catch (std::out_of_range& e) {
66366       {
66367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66368       };
66369     } catch (std::exception& e) {
66370       {
66371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66372       };
66373     } catch (Dali::DaliException e) {
66374       {
66375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66376       };
66377     } catch (...) {
66378       {
66379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66380       };
66381     }
66382   }
66383
66384   jresult = (void *)result;
66385   return jresult;
66386 }
66387
66388
66389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66390   void * jresult ;
66391   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66392   Dali::Toolkit::FlexContainer *result = 0 ;
66393
66394   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66395   if (!arg1) {
66396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66397     return 0;
66398   }
66399   {
66400     try {
66401       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66402     } catch (std::out_of_range& e) {
66403       {
66404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66405       };
66406     } catch (std::exception& e) {
66407       {
66408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66409       };
66410     } catch (Dali::DaliException e) {
66411       {
66412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66413       };
66414     } catch (...) {
66415       {
66416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66417       };
66418     }
66419   }
66420
66421   jresult = (void *)result;
66422   return jresult;
66423 }
66424
66425
66426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66427   void * jresult ;
66428   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66429   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66430   Dali::Toolkit::FlexContainer *result = 0 ;
66431
66432   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66433   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66434   if (!arg2) {
66435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66436     return 0;
66437   }
66438   {
66439     try {
66440       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66441     } catch (std::out_of_range& e) {
66442       {
66443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66444       };
66445     } catch (std::exception& e) {
66446       {
66447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66448       };
66449     } catch (Dali::DaliException e) {
66450       {
66451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66452       };
66453     } catch (...) {
66454       {
66455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66456       };
66457     }
66458   }
66459
66460   jresult = (void *)result;
66461   return jresult;
66462 }
66463
66464
66465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66466   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66467
66468   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66469   {
66470     try {
66471       delete arg1;
66472     } catch (std::out_of_range& e) {
66473       {
66474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66475       };
66476     } catch (std::exception& e) {
66477       {
66478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66479       };
66480     } catch (Dali::DaliException e) {
66481       {
66482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66483       };
66484     } catch (...) {
66485       {
66486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66487       };
66488     }
66489   }
66490
66491 }
66492
66493
66494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66495   void * jresult ;
66496   Dali::Toolkit::FlexContainer result;
66497
66498   {
66499     try {
66500       result = Dali::Toolkit::FlexContainer::New();
66501     } catch (std::out_of_range& e) {
66502       {
66503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66504       };
66505     } catch (std::exception& e) {
66506       {
66507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66508       };
66509     } catch (Dali::DaliException e) {
66510       {
66511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66512       };
66513     } catch (...) {
66514       {
66515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66516       };
66517     }
66518   }
66519
66520   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66521   return jresult;
66522 }
66523
66524
66525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66526   void * jresult ;
66527   Dali::BaseHandle arg1 ;
66528   Dali::BaseHandle *argp1 ;
66529   Dali::Toolkit::FlexContainer result;
66530
66531   argp1 = (Dali::BaseHandle *)jarg1;
66532   if (!argp1) {
66533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66534     return 0;
66535   }
66536   arg1 = *argp1;
66537   {
66538     try {
66539       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66540     } catch (std::out_of_range& e) {
66541       {
66542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66543       };
66544     } catch (std::exception& e) {
66545       {
66546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66547       };
66548     } catch (Dali::DaliException e) {
66549       {
66550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66551       };
66552     } catch (...) {
66553       {
66554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66555       };
66556     }
66557   }
66558
66559   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66560   return jresult;
66561 }
66562
66563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66564   int jresult ;
66565   int result;
66566
66567   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66568   jresult = (int)result;
66569   return jresult;
66570 }
66571
66572
66573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66574   int jresult ;
66575   int result;
66576
66577   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66578   jresult = (int)result;
66579   return jresult;
66580 }
66581
66582
66583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66584   int jresult ;
66585   int result;
66586
66587   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66588   jresult = (int)result;
66589   return jresult;
66590 }
66591
66592
66593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66594   void * jresult ;
66595   Dali::Toolkit::ImageView::Property *result = 0 ;
66596
66597   {
66598     try {
66599       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66600     } catch (std::out_of_range& e) {
66601       {
66602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66603       };
66604     } catch (std::exception& e) {
66605       {
66606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66607       };
66608     } catch (Dali::DaliException e) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66611       };
66612     } catch (...) {
66613       {
66614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66615       };
66616     }
66617   }
66618
66619   jresult = (void *)result;
66620   return jresult;
66621 }
66622
66623
66624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66625   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66626
66627   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66628   {
66629     try {
66630       delete arg1;
66631     } catch (std::out_of_range& e) {
66632       {
66633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66634       };
66635     } catch (std::exception& e) {
66636       {
66637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66638       };
66639     } catch (Dali::DaliException e) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66642       };
66643     } catch (...) {
66644       {
66645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66646       };
66647     }
66648   }
66649
66650 }
66651
66652
66653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66654   void * jresult ;
66655   Dali::Toolkit::ImageView *result = 0 ;
66656
66657   {
66658     try {
66659       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66660     } catch (std::out_of_range& e) {
66661       {
66662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66663       };
66664     } catch (std::exception& e) {
66665       {
66666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66667       };
66668     } catch (Dali::DaliException e) {
66669       {
66670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66671       };
66672     } catch (...) {
66673       {
66674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66675       };
66676     }
66677   }
66678
66679   jresult = (void *)result;
66680   return jresult;
66681 }
66682
66683
66684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66685   void * jresult ;
66686   Dali::Toolkit::ImageView result;
66687
66688   {
66689     try {
66690       result = Dali::Toolkit::ImageView::New();
66691     } catch (std::out_of_range& e) {
66692       {
66693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66694       };
66695     } catch (std::exception& e) {
66696       {
66697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (Dali::DaliException e) {
66700       {
66701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66702       };
66703     } catch (...) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66706       };
66707     }
66708   }
66709
66710   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66711   return jresult;
66712 }
66713
66714
66715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66716   void * jresult ;
66717   std::string *arg1 = 0 ;
66718   Dali::Toolkit::ImageView result;
66719
66720   if (!jarg1) {
66721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66722     return 0;
66723   }
66724   std::string arg1_str(jarg1);
66725   arg1 = &arg1_str;
66726   {
66727     try {
66728       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66729     } catch (std::out_of_range& e) {
66730       {
66731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66732       };
66733     } catch (std::exception& e) {
66734       {
66735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66736       };
66737     } catch (Dali::DaliException e) {
66738       {
66739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66740       };
66741     } catch (...) {
66742       {
66743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66744       };
66745     }
66746   }
66747
66748   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66749
66750   //argout typemap for const std::string&
66751
66752   return jresult;
66753 }
66754
66755
66756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66757   void * jresult ;
66758   std::string *arg1 = 0 ;
66759   Dali::ImageDimensions arg2 ;
66760   Dali::ImageDimensions *argp2 ;
66761   Dali::Toolkit::ImageView result;
66762
66763   if (!jarg1) {
66764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66765     return 0;
66766   }
66767   std::string arg1_str(jarg1);
66768   arg1 = &arg1_str;
66769   argp2 = (Dali::ImageDimensions *)jarg2;
66770   if (!argp2) {
66771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66772     return 0;
66773   }
66774   arg2 = *argp2;
66775   {
66776     try {
66777       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66778     } catch (std::out_of_range& e) {
66779       {
66780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66781       };
66782     } catch (std::exception& e) {
66783       {
66784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66785       };
66786     } catch (Dali::DaliException e) {
66787       {
66788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66789       };
66790     } catch (...) {
66791       {
66792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66793       };
66794     }
66795   }
66796
66797   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66798
66799   //argout typemap for const std::string&
66800
66801   return jresult;
66802 }
66803
66804
66805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66806   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66807
66808   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66809   {
66810     try {
66811       delete arg1;
66812     } catch (std::out_of_range& e) {
66813       {
66814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66815       };
66816     } catch (std::exception& e) {
66817       {
66818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66819       };
66820     } catch (Dali::DaliException e) {
66821       {
66822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66823       };
66824     } catch (...) {
66825       {
66826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66827       };
66828     }
66829   }
66830
66831 }
66832
66833
66834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66835   void * jresult ;
66836   Dali::Toolkit::ImageView *arg1 = 0 ;
66837   Dali::Toolkit::ImageView *result = 0 ;
66838
66839   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66840   if (!arg1) {
66841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66842     return 0;
66843   }
66844   {
66845     try {
66846       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66847     } catch (std::out_of_range& e) {
66848       {
66849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66850       };
66851     } catch (std::exception& e) {
66852       {
66853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66854       };
66855     } catch (Dali::DaliException e) {
66856       {
66857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66858       };
66859     } catch (...) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66862       };
66863     }
66864   }
66865
66866   jresult = (void *)result;
66867   return jresult;
66868 }
66869
66870
66871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66872   void * jresult ;
66873   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66874   Dali::Toolkit::ImageView *arg2 = 0 ;
66875   Dali::Toolkit::ImageView *result = 0 ;
66876
66877   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66878   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66879   if (!arg2) {
66880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66881     return 0;
66882   }
66883   {
66884     try {
66885       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66886     } catch (std::out_of_range& e) {
66887       {
66888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66889       };
66890     } catch (std::exception& e) {
66891       {
66892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66893       };
66894     } catch (Dali::DaliException e) {
66895       {
66896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66897       };
66898     } catch (...) {
66899       {
66900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66901       };
66902     }
66903   }
66904
66905   jresult = (void *)result;
66906   return jresult;
66907 }
66908
66909
66910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66911   void * jresult ;
66912   Dali::BaseHandle arg1 ;
66913   Dali::BaseHandle *argp1 ;
66914   Dali::Toolkit::ImageView result;
66915
66916   argp1 = (Dali::BaseHandle *)jarg1;
66917   if (!argp1) {
66918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66919     return 0;
66920   }
66921   arg1 = *argp1;
66922   {
66923     try {
66924       result = Dali::Toolkit::ImageView::DownCast(arg1);
66925     } catch (std::out_of_range& e) {
66926       {
66927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66928       };
66929     } catch (std::exception& e) {
66930       {
66931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66932       };
66933     } catch (Dali::DaliException e) {
66934       {
66935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66936       };
66937     } catch (...) {
66938       {
66939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66940       };
66941     }
66942   }
66943
66944   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66945   return jresult;
66946 }
66947
66948
66949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66950   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66951   std::string *arg2 = 0 ;
66952
66953   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66954   if (!jarg2) {
66955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66956     return ;
66957   }
66958   std::string arg2_str(jarg2);
66959   arg2 = &arg2_str;
66960   {
66961     try {
66962       (arg1)->SetImage((std::string const &)*arg2);
66963     } catch (std::out_of_range& e) {
66964       {
66965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66966       };
66967     } catch (std::exception& e) {
66968       {
66969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66970       };
66971     } catch (Dali::DaliException e) {
66972       {
66973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66974       };
66975     } catch (...) {
66976       {
66977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66978       };
66979     }
66980   }
66981
66982
66983   //argout typemap for const std::string&
66984
66985 }
66986
66987
66988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66989   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66990   std::string *arg2 = 0 ;
66991   Dali::ImageDimensions arg3 ;
66992   Dali::ImageDimensions *argp3 ;
66993
66994   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66995   if (!jarg2) {
66996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66997     return ;
66998   }
66999   std::string arg2_str(jarg2);
67000   arg2 = &arg2_str;
67001   argp3 = (Dali::ImageDimensions *)jarg3;
67002   if (!argp3) {
67003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67004     return ;
67005   }
67006   arg3 = *argp3;
67007   {
67008     try {
67009       (arg1)->SetImage((std::string const &)*arg2,arg3);
67010     } catch (std::out_of_range& e) {
67011       {
67012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67013       };
67014     } catch (std::exception& e) {
67015       {
67016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67017       };
67018     } catch (Dali::DaliException e) {
67019       {
67020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67021       };
67022     } catch (...) {
67023       {
67024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67025       };
67026     }
67027   }
67028
67029
67030   //argout typemap for const std::string&
67031
67032 }
67033
67034
67035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67036   int jresult ;
67037   int result;
67038
67039   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67040   jresult = (int)result;
67041   return jresult;
67042 }
67043
67044
67045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67046   int jresult ;
67047   int result;
67048
67049   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67050   jresult = (int)result;
67051   return jresult;
67052 }
67053
67054
67055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67056   int jresult ;
67057   int result;
67058
67059   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67060   jresult = (int)result;
67061   return jresult;
67062 }
67063
67064
67065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67066   int jresult ;
67067   int result;
67068
67069   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67070   jresult = (int)result;
67071   return jresult;
67072 }
67073
67074
67075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67076   int jresult ;
67077   int result;
67078
67079   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67080   jresult = (int)result;
67081   return jresult;
67082 }
67083
67084
67085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67086   int jresult ;
67087   int result;
67088
67089   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67090   jresult = (int)result;
67091   return jresult;
67092 }
67093
67094
67095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67096   int jresult ;
67097   int result;
67098
67099   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67100   jresult = (int)result;
67101   return jresult;
67102 }
67103
67104
67105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67106   int jresult ;
67107   int result;
67108
67109   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67110   jresult = (int)result;
67111   return jresult;
67112 }
67113
67114
67115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67116   void * jresult ;
67117   Dali::Toolkit::Model3dView::Property *result = 0 ;
67118
67119   {
67120     try {
67121       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67122     } catch (std::out_of_range& e) {
67123       {
67124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67125       };
67126     } catch (std::exception& e) {
67127       {
67128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67129       };
67130     } catch (Dali::DaliException e) {
67131       {
67132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67133       };
67134     } catch (...) {
67135       {
67136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67137       };
67138     }
67139   }
67140
67141   jresult = (void *)result;
67142   return jresult;
67143 }
67144
67145
67146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67147   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67148
67149   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67150   {
67151     try {
67152       delete arg1;
67153     } catch (std::out_of_range& e) {
67154       {
67155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67156       };
67157     } catch (std::exception& e) {
67158       {
67159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67160       };
67161     } catch (Dali::DaliException e) {
67162       {
67163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67164       };
67165     } catch (...) {
67166       {
67167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67168       };
67169     }
67170   }
67171
67172 }
67173
67174
67175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67176   void * jresult ;
67177   Dali::Toolkit::Model3dView result;
67178
67179   {
67180     try {
67181       result = Dali::Toolkit::Model3dView::New();
67182     } catch (std::out_of_range& e) {
67183       {
67184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67185       };
67186     } catch (std::exception& e) {
67187       {
67188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67189       };
67190     } catch (Dali::DaliException e) {
67191       {
67192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67193       };
67194     } catch (...) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67197       };
67198     }
67199   }
67200
67201   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67202   return jresult;
67203 }
67204
67205
67206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67207   void * jresult ;
67208   std::string *arg1 = 0 ;
67209   std::string *arg2 = 0 ;
67210   std::string *arg3 = 0 ;
67211   Dali::Toolkit::Model3dView result;
67212
67213   if (!jarg1) {
67214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67215     return 0;
67216   }
67217   std::string arg1_str(jarg1);
67218   arg1 = &arg1_str;
67219   if (!jarg2) {
67220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67221     return 0;
67222   }
67223   std::string arg2_str(jarg2);
67224   arg2 = &arg2_str;
67225   if (!jarg3) {
67226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67227     return 0;
67228   }
67229   std::string arg3_str(jarg3);
67230   arg3 = &arg3_str;
67231   {
67232     try {
67233       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67234     } catch (std::out_of_range& e) {
67235       {
67236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67237       };
67238     } catch (std::exception& e) {
67239       {
67240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67241       };
67242     } catch (Dali::DaliException e) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67245       };
67246     } catch (...) {
67247       {
67248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67249       };
67250     }
67251   }
67252
67253   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67254
67255   //argout typemap for const std::string&
67256
67257
67258   //argout typemap for const std::string&
67259
67260
67261   //argout typemap for const std::string&
67262
67263   return jresult;
67264 }
67265
67266
67267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67268   void * jresult ;
67269   Dali::Toolkit::Model3dView *result = 0 ;
67270
67271   {
67272     try {
67273       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67274     } catch (std::out_of_range& e) {
67275       {
67276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67277       };
67278     } catch (std::exception& e) {
67279       {
67280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67281       };
67282     } catch (Dali::DaliException e) {
67283       {
67284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67285       };
67286     } catch (...) {
67287       {
67288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67289       };
67290     }
67291   }
67292
67293   jresult = (void *)result;
67294   return jresult;
67295 }
67296
67297
67298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67299   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67300
67301   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67302   {
67303     try {
67304       delete arg1;
67305     } catch (std::out_of_range& e) {
67306       {
67307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67308       };
67309     } catch (std::exception& e) {
67310       {
67311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67312       };
67313     } catch (Dali::DaliException e) {
67314       {
67315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67316       };
67317     } catch (...) {
67318       {
67319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67320       };
67321     }
67322   }
67323
67324 }
67325
67326
67327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67328   void * jresult ;
67329   Dali::Toolkit::Model3dView *arg1 = 0 ;
67330   Dali::Toolkit::Model3dView *result = 0 ;
67331
67332   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67333   if (!arg1) {
67334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67335     return 0;
67336   }
67337   {
67338     try {
67339       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67340     } catch (std::out_of_range& e) {
67341       {
67342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (std::exception& e) {
67345       {
67346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67347       };
67348     } catch (Dali::DaliException e) {
67349       {
67350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67351       };
67352     } catch (...) {
67353       {
67354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67355       };
67356     }
67357   }
67358
67359   jresult = (void *)result;
67360   return jresult;
67361 }
67362
67363
67364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67365   void * jresult ;
67366   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67367   Dali::Toolkit::Model3dView *arg2 = 0 ;
67368   Dali::Toolkit::Model3dView *result = 0 ;
67369
67370   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67371   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67372   if (!arg2) {
67373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67374     return 0;
67375   }
67376   {
67377     try {
67378       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67379     } catch (std::out_of_range& e) {
67380       {
67381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67382       };
67383     } catch (std::exception& e) {
67384       {
67385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67386       };
67387     } catch (Dali::DaliException e) {
67388       {
67389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67390       };
67391     } catch (...) {
67392       {
67393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67394       };
67395     }
67396   }
67397
67398   jresult = (void *)result;
67399   return jresult;
67400 }
67401
67402
67403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67404   void * jresult ;
67405   Dali::BaseHandle arg1 ;
67406   Dali::BaseHandle *argp1 ;
67407   Dali::Toolkit::Model3dView result;
67408
67409   argp1 = (Dali::BaseHandle *)jarg1;
67410   if (!argp1) {
67411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67412     return 0;
67413   }
67414   arg1 = *argp1;
67415   {
67416     try {
67417       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67418     } catch (std::out_of_range& e) {
67419       {
67420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67421       };
67422     } catch (std::exception& e) {
67423       {
67424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (Dali::DaliException e) {
67427       {
67428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67429       };
67430     } catch (...) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67433       };
67434     }
67435   }
67436
67437   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67438   return jresult;
67439 }
67440
67441
67442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67443   int jresult ;
67444   int result;
67445
67446   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67447   jresult = (int)result;
67448   return jresult;
67449 }
67450
67451
67452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67453   int jresult ;
67454   int result;
67455
67456   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67457   jresult = (int)result;
67458   return jresult;
67459 }
67460
67461
67462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67463   int jresult ;
67464   int result;
67465
67466   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67467   jresult = (int)result;
67468   return jresult;
67469 }
67470
67471
67472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67473   int jresult ;
67474   int result;
67475
67476   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67477   jresult = (int)result;
67478   return jresult;
67479 }
67480
67481
67482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67483   int jresult ;
67484   int result;
67485
67486   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67487   jresult = (int)result;
67488   return jresult;
67489 }
67490
67491
67492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67493   int jresult ;
67494   int result;
67495
67496   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67497   jresult = (int)result;
67498   return jresult;
67499 }
67500
67501
67502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67503   int jresult ;
67504   int result;
67505
67506   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67507   jresult = (int)result;
67508   return jresult;
67509 }
67510
67511
67512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67513   int jresult ;
67514   int result;
67515
67516   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67517   jresult = (int)result;
67518   return jresult;
67519 }
67520
67521
67522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67523   int jresult ;
67524   int result;
67525
67526   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67527   jresult = (int)result;
67528   return jresult;
67529 }
67530
67531
67532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67533   void * jresult ;
67534   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67535
67536   {
67537     try {
67538       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67539     } catch (std::out_of_range& e) {
67540       {
67541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67542       };
67543     } catch (std::exception& e) {
67544       {
67545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67546       };
67547     } catch (Dali::DaliException e) {
67548       {
67549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67550       };
67551     } catch (...) {
67552       {
67553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67554       };
67555     }
67556   }
67557
67558   jresult = (void *)result;
67559   return jresult;
67560 }
67561
67562
67563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67564   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67565
67566   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67567   {
67568     try {
67569       delete arg1;
67570     } catch (std::out_of_range& e) {
67571       {
67572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67573       };
67574     } catch (std::exception& e) {
67575       {
67576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67577       };
67578     } catch (Dali::DaliException e) {
67579       {
67580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67581       };
67582     } catch (...) {
67583       {
67584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67585       };
67586     }
67587   }
67588
67589 }
67590
67591
67592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67593   void * jresult ;
67594   Dali::Toolkit::ScrollBar *result = 0 ;
67595
67596   {
67597     try {
67598       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67599     } catch (std::out_of_range& e) {
67600       {
67601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67602       };
67603     } catch (std::exception& e) {
67604       {
67605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67606       };
67607     } catch (Dali::DaliException e) {
67608       {
67609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67610       };
67611     } catch (...) {
67612       {
67613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67614       };
67615     }
67616   }
67617
67618   jresult = (void *)result;
67619   return jresult;
67620 }
67621
67622
67623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67624   void * jresult ;
67625   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67626   Dali::Toolkit::ScrollBar *result = 0 ;
67627
67628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67629   if (!arg1) {
67630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67631     return 0;
67632   }
67633   {
67634     try {
67635       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67636     } catch (std::out_of_range& e) {
67637       {
67638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67639       };
67640     } catch (std::exception& e) {
67641       {
67642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67643       };
67644     } catch (Dali::DaliException e) {
67645       {
67646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67647       };
67648     } catch (...) {
67649       {
67650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67651       };
67652     }
67653   }
67654
67655   jresult = (void *)result;
67656   return jresult;
67657 }
67658
67659
67660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67661   void * jresult ;
67662   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67663   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67664   Dali::Toolkit::ScrollBar *result = 0 ;
67665
67666   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67667   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67668   if (!arg2) {
67669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67670     return 0;
67671   }
67672   {
67673     try {
67674       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67675     } catch (std::out_of_range& e) {
67676       {
67677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67678       };
67679     } catch (std::exception& e) {
67680       {
67681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67682       };
67683     } catch (Dali::DaliException e) {
67684       {
67685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67686       };
67687     } catch (...) {
67688       {
67689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67690       };
67691     }
67692   }
67693
67694   jresult = (void *)result;
67695   return jresult;
67696 }
67697
67698
67699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67700   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67701
67702   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67703   {
67704     try {
67705       delete arg1;
67706     } catch (std::out_of_range& e) {
67707       {
67708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67709       };
67710     } catch (std::exception& e) {
67711       {
67712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67713       };
67714     } catch (Dali::DaliException e) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67717       };
67718     } catch (...) {
67719       {
67720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67721       };
67722     }
67723   }
67724
67725 }
67726
67727
67728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67729   void * jresult ;
67730   Dali::Toolkit::ScrollBar::Direction arg1 ;
67731   Dali::Toolkit::ScrollBar result;
67732
67733   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67734   {
67735     try {
67736       result = Dali::Toolkit::ScrollBar::New(arg1);
67737     } catch (std::out_of_range& e) {
67738       {
67739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67740       };
67741     } catch (std::exception& e) {
67742       {
67743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67744       };
67745     } catch (Dali::DaliException e) {
67746       {
67747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67748       };
67749     } catch (...) {
67750       {
67751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67752       };
67753     }
67754   }
67755
67756   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67757   return jresult;
67758 }
67759
67760
67761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67762   void * jresult ;
67763   Dali::Toolkit::ScrollBar result;
67764
67765   {
67766     try {
67767       result = Dali::Toolkit::ScrollBar::New();
67768     } catch (std::out_of_range& e) {
67769       {
67770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67771       };
67772     } catch (std::exception& e) {
67773       {
67774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (Dali::DaliException e) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67779       };
67780     } catch (...) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67783       };
67784     }
67785   }
67786
67787   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67788   return jresult;
67789 }
67790
67791
67792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67793   void * jresult ;
67794   Dali::BaseHandle arg1 ;
67795   Dali::BaseHandle *argp1 ;
67796   Dali::Toolkit::ScrollBar result;
67797
67798   argp1 = (Dali::BaseHandle *)jarg1;
67799   if (!argp1) {
67800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67801     return 0;
67802   }
67803   arg1 = *argp1;
67804   {
67805     try {
67806       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67807     } catch (std::out_of_range& e) {
67808       {
67809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67810       };
67811     } catch (std::exception& e) {
67812       {
67813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67814       };
67815     } catch (Dali::DaliException e) {
67816       {
67817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67818       };
67819     } catch (...) {
67820       {
67821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67822       };
67823     }
67824   }
67825
67826   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67827   return jresult;
67828 }
67829
67830
67831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67832   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67833   Dali::Handle arg2 ;
67834   Dali::Property::Index arg3 ;
67835   Dali::Property::Index arg4 ;
67836   Dali::Property::Index arg5 ;
67837   Dali::Property::Index arg6 ;
67838   Dali::Handle *argp2 ;
67839
67840   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67841   argp2 = (Dali::Handle *)jarg2;
67842   if (!argp2) {
67843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67844     return ;
67845   }
67846   arg2 = *argp2;
67847   arg3 = (Dali::Property::Index)jarg3;
67848   arg4 = (Dali::Property::Index)jarg4;
67849   arg5 = (Dali::Property::Index)jarg5;
67850   arg6 = (Dali::Property::Index)jarg6;
67851   {
67852     try {
67853       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67854     } catch (std::out_of_range& e) {
67855       {
67856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67857       };
67858     } catch (std::exception& e) {
67859       {
67860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67861       };
67862     } catch (Dali::DaliException e) {
67863       {
67864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67869       };
67870     }
67871   }
67872
67873 }
67874
67875
67876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67877   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67878   Dali::Actor arg2 ;
67879   Dali::Actor *argp2 ;
67880
67881   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67882   argp2 = (Dali::Actor *)jarg2;
67883   if (!argp2) {
67884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67885     return ;
67886   }
67887   arg2 = *argp2;
67888   {
67889     try {
67890       (arg1)->SetScrollIndicator(arg2);
67891     } catch (std::out_of_range& e) {
67892       {
67893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67894       };
67895     } catch (std::exception& e) {
67896       {
67897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67898       };
67899     } catch (Dali::DaliException e) {
67900       {
67901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67902       };
67903     } catch (...) {
67904       {
67905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67906       };
67907     }
67908   }
67909
67910 }
67911
67912
67913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67914   void * jresult ;
67915   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67916   Dali::Actor result;
67917
67918   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67919   {
67920     try {
67921       result = (arg1)->GetScrollIndicator();
67922     } catch (std::out_of_range& e) {
67923       {
67924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (std::exception& e) {
67927       {
67928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67929       };
67930     } catch (Dali::DaliException e) {
67931       {
67932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67933       };
67934     } catch (...) {
67935       {
67936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67937       };
67938     }
67939   }
67940
67941   jresult = new Dali::Actor((const Dali::Actor &)result);
67942   return jresult;
67943 }
67944
67945
67946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67947   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67948   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67949
67950   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67951   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67952   if (!arg2) {
67953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67954     return ;
67955   }
67956   {
67957     try {
67958       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67966       };
67967     } catch (Dali::DaliException e) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67970       };
67971     } catch (...) {
67972       {
67973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67974       };
67975     }
67976   }
67977
67978 }
67979
67980
67981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67982   void * jresult ;
67983   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67984
67985   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67986   {
67987     try {
67988       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()));
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (...) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68000       };
68001     }
68002   }
68003   return jresult;
68004 }
68005
68006
68007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68008   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68009   Dali::Toolkit::ScrollBar::Direction arg2 ;
68010
68011   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68012   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68013   {
68014     try {
68015       (arg1)->SetScrollDirection(arg2);
68016     } catch (std::out_of_range& e) {
68017       {
68018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68019       };
68020     } catch (std::exception& e) {
68021       {
68022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68023       };
68024     } catch (Dali::DaliException e) {
68025       {
68026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68027       };
68028     } catch (...) {
68029       {
68030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68031       };
68032     }
68033   }
68034
68035 }
68036
68037
68038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68039   int jresult ;
68040   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68041   Dali::Toolkit::ScrollBar::Direction result;
68042
68043   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68044   {
68045     try {
68046       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68047     } catch (std::out_of_range& e) {
68048       {
68049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68050       };
68051     } catch (std::exception& e) {
68052       {
68053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68054       };
68055     } catch (Dali::DaliException e) {
68056       {
68057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68058       };
68059     } catch (...) {
68060       {
68061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68062       };
68063     }
68064   }
68065
68066   jresult = (int)result;
68067   return jresult;
68068 }
68069
68070
68071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68072   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68073   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68074
68075   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68076   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68077   {
68078     try {
68079       (arg1)->SetIndicatorHeightPolicy(arg2);
68080     } catch (std::out_of_range& e) {
68081       {
68082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68083       };
68084     } catch (std::exception& e) {
68085       {
68086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68087       };
68088     } catch (Dali::DaliException e) {
68089       {
68090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68095       };
68096     }
68097   }
68098
68099 }
68100
68101
68102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68103   int jresult ;
68104   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68105   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68106
68107   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68108   {
68109     try {
68110       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (Dali::DaliException e) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68122       };
68123     } catch (...) {
68124       {
68125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68126       };
68127     }
68128   }
68129
68130   jresult = (int)result;
68131   return jresult;
68132 }
68133
68134
68135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68136   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68137   float arg2 ;
68138
68139   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68140   arg2 = (float)jarg2;
68141   {
68142     try {
68143       (arg1)->SetIndicatorFixedHeight(arg2);
68144     } catch (std::out_of_range& e) {
68145       {
68146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68147       };
68148     } catch (std::exception& e) {
68149       {
68150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68151       };
68152     } catch (Dali::DaliException e) {
68153       {
68154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68155       };
68156     } catch (...) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68159       };
68160     }
68161   }
68162
68163 }
68164
68165
68166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68167   float jresult ;
68168   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68169   float result;
68170
68171   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68172   {
68173     try {
68174       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68175     } catch (std::out_of_range& e) {
68176       {
68177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68178       };
68179     } catch (std::exception& e) {
68180       {
68181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68182       };
68183     } catch (Dali::DaliException e) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68186       };
68187     } catch (...) {
68188       {
68189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68190       };
68191     }
68192   }
68193
68194   jresult = result;
68195   return jresult;
68196 }
68197
68198
68199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68200   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68201   float arg2 ;
68202
68203   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68204   arg2 = (float)jarg2;
68205   {
68206     try {
68207       (arg1)->SetIndicatorShowDuration(arg2);
68208     } catch (std::out_of_range& e) {
68209       {
68210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68211       };
68212     } catch (std::exception& e) {
68213       {
68214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68215       };
68216     } catch (Dali::DaliException e) {
68217       {
68218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68223       };
68224     }
68225   }
68226
68227 }
68228
68229
68230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68231   float jresult ;
68232   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68233   float result;
68234
68235   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68236   {
68237     try {
68238       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68239     } catch (std::out_of_range& e) {
68240       {
68241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68242       };
68243     } catch (std::exception& e) {
68244       {
68245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68246       };
68247     } catch (Dali::DaliException e) {
68248       {
68249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68250       };
68251     } catch (...) {
68252       {
68253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68254       };
68255     }
68256   }
68257
68258   jresult = result;
68259   return jresult;
68260 }
68261
68262
68263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68264   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68265   float arg2 ;
68266
68267   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68268   arg2 = (float)jarg2;
68269   {
68270     try {
68271       (arg1)->SetIndicatorHideDuration(arg2);
68272     } catch (std::out_of_range& e) {
68273       {
68274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68275       };
68276     } catch (std::exception& e) {
68277       {
68278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68279       };
68280     } catch (Dali::DaliException e) {
68281       {
68282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68283       };
68284     } catch (...) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68287       };
68288     }
68289   }
68290
68291 }
68292
68293
68294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68295   float jresult ;
68296   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68297   float result;
68298
68299   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68300   {
68301     try {
68302       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68303     } catch (std::out_of_range& e) {
68304       {
68305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68306       };
68307     } catch (std::exception& e) {
68308       {
68309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (Dali::DaliException e) {
68312       {
68313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68314       };
68315     } catch (...) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68318       };
68319     }
68320   }
68321
68322   jresult = result;
68323   return jresult;
68324 }
68325
68326
68327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68328   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68329
68330   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68331   {
68332     try {
68333       (arg1)->ShowIndicator();
68334     } catch (std::out_of_range& e) {
68335       {
68336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68337       };
68338     } catch (std::exception& e) {
68339       {
68340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68341       };
68342     } catch (Dali::DaliException e) {
68343       {
68344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68345       };
68346     } catch (...) {
68347       {
68348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68349       };
68350     }
68351   }
68352
68353 }
68354
68355
68356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68357   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68358
68359   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68360   {
68361     try {
68362       (arg1)->HideIndicator();
68363     } catch (std::out_of_range& e) {
68364       {
68365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68366       };
68367     } catch (std::exception& e) {
68368       {
68369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68370       };
68371     } catch (Dali::DaliException e) {
68372       {
68373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68374       };
68375     } catch (...) {
68376       {
68377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68378       };
68379     }
68380   }
68381
68382 }
68383
68384
68385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68386   void * jresult ;
68387   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68388   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68389
68390   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68391   {
68392     try {
68393       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68394     } catch (std::out_of_range& e) {
68395       {
68396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68397       };
68398     } catch (std::exception& e) {
68399       {
68400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68401       };
68402     } catch (Dali::DaliException e) {
68403       {
68404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68405       };
68406     } catch (...) {
68407       {
68408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68409       };
68410     }
68411   }
68412
68413   jresult = (void *)result;
68414   return jresult;
68415 }
68416
68417
68418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68419   void * jresult ;
68420   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68421   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68422
68423   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68424   {
68425     try {
68426       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68427     } catch (std::out_of_range& e) {
68428       {
68429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68430       };
68431     } catch (std::exception& e) {
68432       {
68433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (Dali::DaliException e) {
68436       {
68437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68438       };
68439     } catch (...) {
68440       {
68441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68442       };
68443     }
68444   }
68445
68446   jresult = (void *)result;
68447   return jresult;
68448 }
68449
68450
68451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68452   int jresult ;
68453   int result;
68454
68455   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68456   jresult = (int)result;
68457   return jresult;
68458 }
68459
68460
68461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68462   int jresult ;
68463   int result;
68464
68465   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68466   jresult = (int)result;
68467   return jresult;
68468 }
68469
68470
68471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68472   int jresult ;
68473   int result;
68474
68475   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68476   jresult = (int)result;
68477   return jresult;
68478 }
68479
68480
68481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68482   int jresult ;
68483   int result;
68484
68485   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68486   jresult = (int)result;
68487   return jresult;
68488 }
68489
68490
68491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68492   int jresult ;
68493   int result;
68494
68495   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68496   jresult = (int)result;
68497   return jresult;
68498 }
68499
68500
68501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68502   int jresult ;
68503   int result;
68504
68505   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68506   jresult = (int)result;
68507   return jresult;
68508 }
68509
68510
68511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68512   int jresult ;
68513   int result;
68514
68515   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68516   jresult = (int)result;
68517   return jresult;
68518 }
68519
68520
68521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68522   int jresult ;
68523   int result;
68524
68525   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68526   jresult = (int)result;
68527   return jresult;
68528 }
68529
68530
68531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68532   int jresult ;
68533   int result;
68534
68535   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68536   jresult = (int)result;
68537   return jresult;
68538 }
68539
68540
68541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68542   int jresult ;
68543   int result;
68544
68545   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68546   jresult = (int)result;
68547   return jresult;
68548 }
68549
68550
68551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68552   int jresult ;
68553   int result;
68554
68555   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68556   jresult = (int)result;
68557   return jresult;
68558 }
68559
68560
68561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68562   int jresult ;
68563   int result;
68564
68565   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68566   jresult = (int)result;
68567   return jresult;
68568 }
68569
68570
68571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68572   int jresult ;
68573   int result;
68574
68575   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68576   jresult = (int)result;
68577   return jresult;
68578 }
68579
68580
68581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68582   int jresult ;
68583   int result;
68584
68585   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68586   jresult = (int)result;
68587   return jresult;
68588 }
68589
68590
68591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68592   void * jresult ;
68593   Dali::Toolkit::Scrollable::Property *result = 0 ;
68594
68595   {
68596     try {
68597       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68598     } catch (std::out_of_range& e) {
68599       {
68600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68601       };
68602     } catch (std::exception& e) {
68603       {
68604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68605       };
68606     } catch (Dali::DaliException e) {
68607       {
68608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68609       };
68610     } catch (...) {
68611       {
68612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68613       };
68614     }
68615   }
68616
68617   jresult = (void *)result;
68618   return jresult;
68619 }
68620
68621
68622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68623   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68624
68625   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68626   {
68627     try {
68628       delete arg1;
68629     } catch (std::out_of_range& e) {
68630       {
68631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68632       };
68633     } catch (std::exception& e) {
68634       {
68635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68636       };
68637     } catch (Dali::DaliException e) {
68638       {
68639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68640       };
68641     } catch (...) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68644       };
68645     }
68646   }
68647
68648 }
68649
68650
68651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68652   void * jresult ;
68653   Dali::Toolkit::Scrollable *result = 0 ;
68654
68655   {
68656     try {
68657       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68658     } catch (std::out_of_range& e) {
68659       {
68660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68661       };
68662     } catch (std::exception& e) {
68663       {
68664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68665       };
68666     } catch (Dali::DaliException e) {
68667       {
68668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68669       };
68670     } catch (...) {
68671       {
68672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68673       };
68674     }
68675   }
68676
68677   jresult = (void *)result;
68678   return jresult;
68679 }
68680
68681
68682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68683   void * jresult ;
68684   Dali::Toolkit::Scrollable *arg1 = 0 ;
68685   Dali::Toolkit::Scrollable *result = 0 ;
68686
68687   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68688   if (!arg1) {
68689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68690     return 0;
68691   }
68692   {
68693     try {
68694       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68695     } catch (std::out_of_range& e) {
68696       {
68697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68698       };
68699     } catch (std::exception& e) {
68700       {
68701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68702       };
68703     } catch (Dali::DaliException e) {
68704       {
68705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68706       };
68707     } catch (...) {
68708       {
68709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68710       };
68711     }
68712   }
68713
68714   jresult = (void *)result;
68715   return jresult;
68716 }
68717
68718
68719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68720   void * jresult ;
68721   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68722   Dali::Toolkit::Scrollable *arg2 = 0 ;
68723   Dali::Toolkit::Scrollable *result = 0 ;
68724
68725   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68726   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68727   if (!arg2) {
68728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68729     return 0;
68730   }
68731   {
68732     try {
68733       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68734     } catch (std::out_of_range& e) {
68735       {
68736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68737       };
68738     } catch (std::exception& e) {
68739       {
68740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68741       };
68742     } catch (Dali::DaliException e) {
68743       {
68744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68745       };
68746     } catch (...) {
68747       {
68748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68749       };
68750     }
68751   }
68752
68753   jresult = (void *)result;
68754   return jresult;
68755 }
68756
68757
68758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68759   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68760
68761   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68762   {
68763     try {
68764       delete arg1;
68765     } catch (std::out_of_range& e) {
68766       {
68767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68768       };
68769     } catch (std::exception& e) {
68770       {
68771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68772       };
68773     } catch (Dali::DaliException e) {
68774       {
68775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68776       };
68777     } catch (...) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68780       };
68781     }
68782   }
68783
68784 }
68785
68786
68787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68788   void * jresult ;
68789   Dali::BaseHandle arg1 ;
68790   Dali::BaseHandle *argp1 ;
68791   Dali::Toolkit::Scrollable result;
68792
68793   argp1 = (Dali::BaseHandle *)jarg1;
68794   if (!argp1) {
68795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68796     return 0;
68797   }
68798   arg1 = *argp1;
68799   {
68800     try {
68801       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (Dali::DaliException e) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68817       };
68818     }
68819   }
68820
68821   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68822   return jresult;
68823 }
68824
68825
68826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68827   unsigned int jresult ;
68828   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68829   bool result;
68830
68831   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68832   {
68833     try {
68834       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68835     } catch (std::out_of_range& e) {
68836       {
68837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68838       };
68839     } catch (std::exception& e) {
68840       {
68841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68842       };
68843     } catch (Dali::DaliException e) {
68844       {
68845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68846       };
68847     } catch (...) {
68848       {
68849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68850       };
68851     }
68852   }
68853
68854   jresult = result;
68855   return jresult;
68856 }
68857
68858
68859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68860   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68861   bool arg2 ;
68862
68863   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68864   arg2 = jarg2 ? true : false;
68865   {
68866     try {
68867       (arg1)->SetOvershootEnabled(arg2);
68868     } catch (std::out_of_range& e) {
68869       {
68870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68871       };
68872     } catch (std::exception& e) {
68873       {
68874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68875       };
68876     } catch (Dali::DaliException e) {
68877       {
68878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68879       };
68880     } catch (...) {
68881       {
68882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68883       };
68884     }
68885   }
68886
68887 }
68888
68889
68890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68891   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68892   Dali::Vector4 *arg2 = 0 ;
68893
68894   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68895   arg2 = (Dali::Vector4 *)jarg2;
68896   if (!arg2) {
68897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68898     return ;
68899   }
68900   {
68901     try {
68902       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68903     } catch (std::out_of_range& e) {
68904       {
68905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68906       };
68907     } catch (std::exception& e) {
68908       {
68909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68910       };
68911     } catch (Dali::DaliException e) {
68912       {
68913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68914       };
68915     } catch (...) {
68916       {
68917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68918       };
68919     }
68920   }
68921
68922 }
68923
68924
68925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68926   void * jresult ;
68927   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68928   Dali::Vector4 result;
68929
68930   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68931   {
68932     try {
68933       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68934     } catch (std::out_of_range& e) {
68935       {
68936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68937       };
68938     } catch (std::exception& e) {
68939       {
68940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68941       };
68942     } catch (Dali::DaliException e) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68945       };
68946     } catch (...) {
68947       {
68948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68949       };
68950     }
68951   }
68952
68953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68954   return jresult;
68955 }
68956
68957
68958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68959   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68960   float arg2 ;
68961
68962   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68963   arg2 = (float)jarg2;
68964   {
68965     try {
68966       (arg1)->SetOvershootAnimationSpeed(arg2);
68967     } catch (std::out_of_range& e) {
68968       {
68969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68970       };
68971     } catch (std::exception& e) {
68972       {
68973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68974       };
68975     } catch (Dali::DaliException e) {
68976       {
68977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68978       };
68979     } catch (...) {
68980       {
68981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68982       };
68983     }
68984   }
68985
68986 }
68987
68988
68989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68990   float jresult ;
68991   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68992   float result;
68993
68994   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68995   {
68996     try {
68997       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68998     } catch (std::out_of_range& e) {
68999       {
69000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69001       };
69002     } catch (std::exception& e) {
69003       {
69004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69005       };
69006     } catch (Dali::DaliException e) {
69007       {
69008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69009       };
69010     } catch (...) {
69011       {
69012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69013       };
69014     }
69015   }
69016
69017   jresult = result;
69018   return jresult;
69019 }
69020
69021
69022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69023   void * jresult ;
69024   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69025   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69026
69027   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69028   {
69029     try {
69030       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69031     } catch (std::out_of_range& e) {
69032       {
69033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (std::exception& e) {
69036       {
69037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69038       };
69039     } catch (Dali::DaliException e) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69042       };
69043     } catch (...) {
69044       {
69045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69046       };
69047     }
69048   }
69049
69050   jresult = (void *)result;
69051   return jresult;
69052 }
69053
69054
69055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69056   void * jresult ;
69057   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69058   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69059
69060   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69061   {
69062     try {
69063       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69064     } catch (std::out_of_range& e) {
69065       {
69066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69067       };
69068     } catch (std::exception& e) {
69069       {
69070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69071       };
69072     } catch (Dali::DaliException e) {
69073       {
69074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69075       };
69076     } catch (...) {
69077       {
69078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69079       };
69080     }
69081   }
69082
69083   jresult = (void *)result;
69084   return jresult;
69085 }
69086
69087
69088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69089   void * jresult ;
69090   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69091   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69092
69093   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69094   {
69095     try {
69096       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69097     } catch (std::out_of_range& e) {
69098       {
69099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (std::exception& e) {
69102       {
69103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69104       };
69105     } catch (Dali::DaliException e) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69108       };
69109     } catch (...) {
69110       {
69111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69112       };
69113     }
69114   }
69115
69116   jresult = (void *)result;
69117   return jresult;
69118 }
69119
69120
69121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69122   unsigned int jresult ;
69123   Dali::Toolkit::ControlOrientation::Type arg1 ;
69124   bool result;
69125
69126   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69127   {
69128     try {
69129       result = (bool)Dali::Toolkit::IsVertical(arg1);
69130     } catch (std::out_of_range& e) {
69131       {
69132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69133       };
69134     } catch (std::exception& e) {
69135       {
69136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69137       };
69138     } catch (Dali::DaliException e) {
69139       {
69140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69141       };
69142     } catch (...) {
69143       {
69144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69145       };
69146     }
69147   }
69148
69149   jresult = result;
69150   return jresult;
69151 }
69152
69153
69154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69155   unsigned int jresult ;
69156   Dali::Toolkit::ControlOrientation::Type arg1 ;
69157   bool result;
69158
69159   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69160   {
69161     try {
69162       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69163     } catch (std::out_of_range& e) {
69164       {
69165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69166       };
69167     } catch (std::exception& e) {
69168       {
69169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69170       };
69171     } catch (Dali::DaliException e) {
69172       {
69173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69174       };
69175     } catch (...) {
69176       {
69177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69178       };
69179     }
69180   }
69181
69182   jresult = result;
69183   return jresult;
69184 }
69185
69186
69187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69188   void * jresult ;
69189   unsigned int arg1 ;
69190   unsigned int arg2 ;
69191   Dali::Toolkit::ItemRange *result = 0 ;
69192
69193   arg1 = (unsigned int)jarg1;
69194   arg2 = (unsigned int)jarg2;
69195   {
69196     try {
69197       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69198     } catch (std::out_of_range& e) {
69199       {
69200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69201       };
69202     } catch (std::exception& e) {
69203       {
69204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (Dali::DaliException e) {
69207       {
69208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69209       };
69210     } catch (...) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69213       };
69214     }
69215   }
69216
69217   jresult = (void *)result;
69218   return jresult;
69219 }
69220
69221
69222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69223   void * jresult ;
69224   Dali::Toolkit::ItemRange *arg1 = 0 ;
69225   Dali::Toolkit::ItemRange *result = 0 ;
69226
69227   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69228   if (!arg1) {
69229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69230     return 0;
69231   }
69232   {
69233     try {
69234       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69242       };
69243     } catch (Dali::DaliException e) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69246       };
69247     } catch (...) {
69248       {
69249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69250       };
69251     }
69252   }
69253
69254   jresult = (void *)result;
69255   return jresult;
69256 }
69257
69258
69259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69260   void * jresult ;
69261   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69262   Dali::Toolkit::ItemRange *arg2 = 0 ;
69263   Dali::Toolkit::ItemRange *result = 0 ;
69264
69265   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69266   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69267   if (!arg2) {
69268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69269     return 0;
69270   }
69271   {
69272     try {
69273       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69274     } catch (std::out_of_range& e) {
69275       {
69276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (std::exception& e) {
69279       {
69280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69281       };
69282     } catch (Dali::DaliException e) {
69283       {
69284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69285       };
69286     } catch (...) {
69287       {
69288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69289       };
69290     }
69291   }
69292
69293   jresult = (void *)result;
69294   return jresult;
69295 }
69296
69297
69298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69299   unsigned int jresult ;
69300   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69301   unsigned int arg2 ;
69302   bool result;
69303
69304   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69305   arg2 = (unsigned int)jarg2;
69306   {
69307     try {
69308       result = (bool)(arg1)->Within(arg2);
69309     } catch (std::out_of_range& e) {
69310       {
69311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69312       };
69313     } catch (std::exception& e) {
69314       {
69315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (Dali::DaliException e) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69320       };
69321     } catch (...) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69324       };
69325     }
69326   }
69327
69328   jresult = result;
69329   return jresult;
69330 }
69331
69332
69333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69334   void * jresult ;
69335   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69336   Dali::Toolkit::ItemRange *arg2 = 0 ;
69337   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69338
69339   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69340   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69341   if (!arg2) {
69342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69343     return 0;
69344   }
69345   {
69346     try {
69347       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69348     } catch (std::out_of_range& e) {
69349       {
69350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69351       };
69352     } catch (std::exception& e) {
69353       {
69354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69355       };
69356     } catch (Dali::DaliException e) {
69357       {
69358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69359       };
69360     } catch (...) {
69361       {
69362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69363       };
69364     }
69365   }
69366
69367   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69368   return jresult;
69369 }
69370
69371
69372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69373   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69374   unsigned int arg2 ;
69375
69376   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69377   arg2 = (unsigned int)jarg2;
69378   if (arg1) (arg1)->begin = arg2;
69379 }
69380
69381
69382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69383   unsigned int jresult ;
69384   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69385   unsigned int result;
69386
69387   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69388   result = (unsigned int) ((arg1)->begin);
69389   jresult = result;
69390   return jresult;
69391 }
69392
69393
69394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69395   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69396   unsigned int arg2 ;
69397
69398   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69399   arg2 = (unsigned int)jarg2;
69400   if (arg1) (arg1)->end = arg2;
69401 }
69402
69403
69404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69405   unsigned int jresult ;
69406   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69407   unsigned int result;
69408
69409   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69410   result = (unsigned int) ((arg1)->end);
69411   jresult = result;
69412   return jresult;
69413 }
69414
69415
69416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69417   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69418
69419   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69420   {
69421     try {
69422       delete arg1;
69423     } catch (std::out_of_range& e) {
69424       {
69425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69426       };
69427     } catch (std::exception& e) {
69428       {
69429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69430       };
69431     } catch (Dali::DaliException e) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69434       };
69435     } catch (...) {
69436       {
69437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69438       };
69439     }
69440   }
69441
69442 }
69443
69444
69445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69446   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69447
69448   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69449   {
69450     try {
69451       delete arg1;
69452     } catch (std::out_of_range& e) {
69453       {
69454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69455       };
69456     } catch (std::exception& e) {
69457       {
69458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69459       };
69460     } catch (Dali::DaliException e) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69463       };
69464     } catch (...) {
69465       {
69466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69467       };
69468     }
69469   }
69470
69471 }
69472
69473
69474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69475   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69476   Dali::Toolkit::ControlOrientation::Type arg2 ;
69477
69478   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69479   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69480   {
69481     try {
69482       (arg1)->SetOrientation(arg2);
69483     } catch (std::out_of_range& e) {
69484       {
69485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69486       };
69487     } catch (std::exception& e) {
69488       {
69489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69490       };
69491     } catch (Dali::DaliException e) {
69492       {
69493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69494       };
69495     } catch (...) {
69496       {
69497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69498       };
69499     }
69500   }
69501
69502 }
69503
69504
69505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69506   int jresult ;
69507   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69508   Dali::Toolkit::ControlOrientation::Type result;
69509
69510   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69511   {
69512     try {
69513       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69514     } catch (std::out_of_range& e) {
69515       {
69516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (std::exception& e) {
69519       {
69520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69521       };
69522     } catch (Dali::DaliException e) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69529       };
69530     }
69531   }
69532
69533   jresult = (int)result;
69534   return jresult;
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69539   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69540   Dali::Property::Map *arg2 = 0 ;
69541
69542   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69543   arg2 = (Dali::Property::Map *)jarg2;
69544   if (!arg2) {
69545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69546     return ;
69547   }
69548   {
69549     try {
69550       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69551     } catch (std::out_of_range& e) {
69552       {
69553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69554       };
69555     } catch (std::exception& e) {
69556       {
69557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69558       };
69559     } catch (Dali::DaliException e) {
69560       {
69561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69562       };
69563     } catch (...) {
69564       {
69565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69566       };
69567     }
69568   }
69569
69570 }
69571
69572
69573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69574   void * jresult ;
69575   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69576   Dali::Property::Map result;
69577
69578   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69579   {
69580     try {
69581       result = (arg1)->GetLayoutProperties();
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::Property::Map((const Dali::Property::Map &)result);
69602   return jresult;
69603 }
69604
69605
69606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69607   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69608   unsigned int arg2 ;
69609   Dali::Vector3 *arg3 = 0 ;
69610   Dali::Vector3 *arg4 = 0 ;
69611
69612   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69613   arg2 = (unsigned int)jarg2;
69614   arg3 = (Dali::Vector3 *)jarg3;
69615   if (!arg3) {
69616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69617     return ;
69618   }
69619   arg4 = (Dali::Vector3 *)jarg4;
69620   if (!arg4) {
69621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69622     return ;
69623   }
69624   {
69625     try {
69626       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69627     } catch (std::out_of_range& e) {
69628       {
69629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (std::exception& e) {
69632       {
69633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69634       };
69635     } catch (Dali::DaliException e) {
69636       {
69637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69638       };
69639     } catch (...) {
69640       {
69641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69642       };
69643     }
69644   }
69645
69646 }
69647
69648
69649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69650   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69651   Dali::Vector3 *arg2 = 0 ;
69652
69653   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69654   arg2 = (Dali::Vector3 *)jarg2;
69655   if (!arg2) {
69656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69657     return ;
69658   }
69659   {
69660     try {
69661       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69662     } catch (std::out_of_range& e) {
69663       {
69664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69665       };
69666     } catch (std::exception& e) {
69667       {
69668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69669       };
69670     } catch (Dali::DaliException e) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69673       };
69674     } catch (...) {
69675       {
69676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69677       };
69678     }
69679   }
69680
69681 }
69682
69683
69684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69685   float jresult ;
69686   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69687   unsigned int arg2 ;
69688   Dali::Vector3 arg3 ;
69689   Dali::Vector3 *argp3 ;
69690   float result;
69691
69692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69693   arg2 = (unsigned int)jarg2;
69694   argp3 = (Dali::Vector3 *)jarg3;
69695   if (!argp3) {
69696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69697     return 0;
69698   }
69699   arg3 = *argp3;
69700   {
69701     try {
69702       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69718       };
69719     }
69720   }
69721
69722   jresult = result;
69723   return jresult;
69724 }
69725
69726
69727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69728   float jresult ;
69729   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69730   float arg2 ;
69731   float result;
69732
69733   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69734   arg2 = (float)jarg2;
69735   {
69736     try {
69737       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69753       };
69754     }
69755   }
69756
69757   jresult = result;
69758   return jresult;
69759 }
69760
69761
69762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69763   float jresult ;
69764   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69765   unsigned int arg2 ;
69766   float result;
69767
69768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69769   arg2 = (unsigned int)jarg2;
69770   {
69771     try {
69772       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69773     } catch (std::out_of_range& e) {
69774       {
69775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (std::exception& e) {
69778       {
69779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69780       };
69781     } catch (Dali::DaliException e) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69784       };
69785     } catch (...) {
69786       {
69787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69788       };
69789     }
69790   }
69791
69792   jresult = result;
69793   return jresult;
69794 }
69795
69796
69797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69798   void * jresult ;
69799   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69800   float arg2 ;
69801   Dali::Vector3 arg3 ;
69802   Dali::Vector3 *argp3 ;
69803   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69804
69805   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69806   arg2 = (float)jarg2;
69807   argp3 = (Dali::Vector3 *)jarg3;
69808   if (!argp3) {
69809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69810     return 0;
69811   }
69812   arg3 = *argp3;
69813   {
69814     try {
69815       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69816     } catch (std::out_of_range& e) {
69817       {
69818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69819       };
69820     } catch (std::exception& e) {
69821       {
69822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69823       };
69824     } catch (Dali::DaliException e) {
69825       {
69826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69827       };
69828     } catch (...) {
69829       {
69830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69831       };
69832     }
69833   }
69834
69835   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69836   return jresult;
69837 }
69838
69839
69840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69841   float jresult ;
69842   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69843   int arg2 ;
69844   float arg3 ;
69845   Dali::Vector3 *arg4 = 0 ;
69846   float result;
69847
69848   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69849   arg2 = (int)jarg2;
69850   arg3 = (float)jarg3;
69851   arg4 = (Dali::Vector3 *)jarg4;
69852   if (!arg4) {
69853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69854     return 0;
69855   }
69856   {
69857     try {
69858       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69859     } catch (std::out_of_range& e) {
69860       {
69861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69862       };
69863     } catch (std::exception& e) {
69864       {
69865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69866       };
69867     } catch (Dali::DaliException e) {
69868       {
69869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69870       };
69871     } catch (...) {
69872       {
69873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69874       };
69875     }
69876   }
69877
69878   jresult = result;
69879   return jresult;
69880 }
69881
69882
69883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69884   unsigned int jresult ;
69885   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69886   Dali::Vector3 arg2 ;
69887   Dali::Vector3 *argp2 ;
69888   unsigned int result;
69889
69890   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69891   argp2 = (Dali::Vector3 *)jarg2;
69892   if (!argp2) {
69893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69894     return 0;
69895   }
69896   arg2 = *argp2;
69897   {
69898     try {
69899       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69900     } catch (std::out_of_range& e) {
69901       {
69902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69903       };
69904     } catch (std::exception& e) {
69905       {
69906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69907       };
69908     } catch (Dali::DaliException e) {
69909       {
69910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69911       };
69912     } catch (...) {
69913       {
69914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69915       };
69916     }
69917   }
69918
69919   jresult = result;
69920   return jresult;
69921 }
69922
69923
69924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69925   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69926   unsigned int arg2 ;
69927   Dali::Vector3 *arg3 = 0 ;
69928   Dali::Vector3 *arg4 = 0 ;
69929
69930   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69931   arg2 = (unsigned int)jarg2;
69932   arg3 = (Dali::Vector3 *)jarg3;
69933   if (!arg3) {
69934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69935     return ;
69936   }
69937   arg4 = (Dali::Vector3 *)jarg4;
69938   if (!arg4) {
69939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69940     return ;
69941   }
69942   {
69943     try {
69944       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69945     } catch (std::out_of_range& e) {
69946       {
69947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69948       };
69949     } catch (std::exception& e) {
69950       {
69951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69952       };
69953     } catch (Dali::DaliException e) {
69954       {
69955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69956       };
69957     } catch (...) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69960       };
69961     }
69962   }
69963
69964 }
69965
69966
69967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69968   void * jresult ;
69969   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69970   Dali::Degree result;
69971
69972   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69973   {
69974     try {
69975       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69976     } catch (std::out_of_range& e) {
69977       {
69978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69979       };
69980     } catch (std::exception& e) {
69981       {
69982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (Dali::DaliException e) {
69985       {
69986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69987       };
69988     } catch (...) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69991       };
69992     }
69993   }
69994
69995   jresult = new Dali::Degree((const Dali::Degree &)result);
69996   return jresult;
69997 }
69998
69999
70000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70001   float jresult ;
70002   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70003   float result;
70004
70005   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70006   {
70007     try {
70008       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
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 = result;
70029   return jresult;
70030 }
70031
70032
70033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70034   float jresult ;
70035   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70036   float result;
70037
70038   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70039   {
70040     try {
70041       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70042     } catch (std::out_of_range& e) {
70043       {
70044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70045       };
70046     } catch (std::exception& e) {
70047       {
70048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70049       };
70050     } catch (Dali::DaliException e) {
70051       {
70052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70053       };
70054     } catch (...) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70057       };
70058     }
70059   }
70060
70061   jresult = result;
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70067   float jresult ;
70068   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70069   float result;
70070
70071   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70072   {
70073     try {
70074       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70075     } catch (std::out_of_range& e) {
70076       {
70077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (std::exception& e) {
70080       {
70081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (Dali::DaliException e) {
70084       {
70085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70086       };
70087     } catch (...) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70090       };
70091     }
70092   }
70093
70094   jresult = result;
70095   return jresult;
70096 }
70097
70098
70099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70100   int jresult ;
70101   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70102   int arg2 ;
70103   int arg3 ;
70104   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70105   bool arg5 ;
70106   int result;
70107
70108   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70109   arg2 = (int)jarg2;
70110   arg3 = (int)jarg3;
70111   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70112   arg5 = jarg5 ? true : false;
70113   {
70114     try {
70115       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70116     } catch (std::out_of_range& e) {
70117       {
70118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70119       };
70120     } catch (std::exception& e) {
70121       {
70122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70123       };
70124     } catch (Dali::DaliException e) {
70125       {
70126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70127       };
70128     } catch (...) {
70129       {
70130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70131       };
70132     }
70133   }
70134
70135   jresult = result;
70136   return jresult;
70137 }
70138
70139
70140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70141   float jresult ;
70142   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70143   float result;
70144
70145   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70146   {
70147     try {
70148       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70149     } catch (std::out_of_range& e) {
70150       {
70151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70152       };
70153     } catch (std::exception& e) {
70154       {
70155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70156       };
70157     } catch (Dali::DaliException e) {
70158       {
70159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70160       };
70161     } catch (...) {
70162       {
70163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70164       };
70165     }
70166   }
70167
70168   jresult = result;
70169   return jresult;
70170 }
70171
70172
70173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70174   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70175   Dali::Actor *arg2 = 0 ;
70176   int arg3 ;
70177   Dali::Vector3 *arg4 = 0 ;
70178   Dali::Actor *arg5 = 0 ;
70179
70180   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70181   arg2 = (Dali::Actor *)jarg2;
70182   if (!arg2) {
70183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70184     return ;
70185   }
70186   arg3 = (int)jarg3;
70187   arg4 = (Dali::Vector3 *)jarg4;
70188   if (!arg4) {
70189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70190     return ;
70191   }
70192   arg5 = (Dali::Actor *)jarg5;
70193   if (!arg5) {
70194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70195     return ;
70196   }
70197   {
70198     try {
70199       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70200     } catch (std::out_of_range& e) {
70201       {
70202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70203       };
70204     } catch (std::exception& e) {
70205       {
70206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70207       };
70208     } catch (Dali::DaliException e) {
70209       {
70210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70211       };
70212     } catch (...) {
70213       {
70214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70215       };
70216     }
70217   }
70218
70219 }
70220
70221
70222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70223   void * jresult ;
70224   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70225   int arg2 ;
70226   float arg3 ;
70227   Dali::Vector3 *arg4 = 0 ;
70228   Dali::Vector3 result;
70229
70230   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70231   arg2 = (int)jarg2;
70232   arg3 = (float)jarg3;
70233   arg4 = (Dali::Vector3 *)jarg4;
70234   if (!arg4) {
70235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70236     return 0;
70237   }
70238   {
70239     try {
70240       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70241     } catch (std::out_of_range& e) {
70242       {
70243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70244       };
70245     } catch (std::exception& e) {
70246       {
70247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70248       };
70249     } catch (Dali::DaliException e) {
70250       {
70251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70252       };
70253     } catch (...) {
70254       {
70255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70256       };
70257     }
70258   }
70259
70260   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70261   return jresult;
70262 }
70263
70264
70265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70266   void * jresult ;
70267   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70268   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70269
70270   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70271   {
70272     try {
70273       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70274     } catch (std::out_of_range& e) {
70275       {
70276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70277       };
70278     } catch (std::exception& e) {
70279       {
70280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70281       };
70282     } catch (Dali::DaliException e) {
70283       {
70284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70285       };
70286     } catch (...) {
70287       {
70288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70289       };
70290     }
70291   }
70292
70293   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70294   return jresult;
70295 }
70296
70297
70298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70299   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70300
70301   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70302   {
70303     try {
70304       delete arg1;
70305     } catch (std::out_of_range& e) {
70306       {
70307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70308       };
70309     } catch (std::exception& e) {
70310       {
70311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70312       };
70313     } catch (Dali::DaliException e) {
70314       {
70315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70316       };
70317     } catch (...) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70320       };
70321     }
70322   }
70323
70324 }
70325
70326
70327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70328   unsigned int jresult ;
70329   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70330   unsigned int result;
70331
70332   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70333   {
70334     try {
70335       result = (unsigned int)(arg1)->GetNumberOfItems();
70336     } catch (std::out_of_range& e) {
70337       {
70338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70339       };
70340     } catch (std::exception& e) {
70341       {
70342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70343       };
70344     } catch (Dali::DaliException e) {
70345       {
70346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70347       };
70348     } catch (...) {
70349       {
70350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70351       };
70352     }
70353   }
70354
70355   jresult = result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70361   void * jresult ;
70362   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70363   unsigned int arg2 ;
70364   Dali::Actor result;
70365
70366   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70367   arg2 = (unsigned int)jarg2;
70368   {
70369     try {
70370       result = (arg1)->NewItem(arg2);
70371     } catch (std::out_of_range& e) {
70372       {
70373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70374       };
70375     } catch (std::exception& e) {
70376       {
70377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70378       };
70379     } catch (Dali::DaliException e) {
70380       {
70381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70382       };
70383     } catch (...) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70386       };
70387     }
70388   }
70389
70390   jresult = new Dali::Actor((const Dali::Actor &)result);
70391   return jresult;
70392 }
70393
70394
70395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70396   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70397   unsigned int arg2 ;
70398   Dali::Actor arg3 ;
70399   Dali::Actor *argp3 ;
70400
70401   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70402   arg2 = (unsigned int)jarg2;
70403   argp3 = (Dali::Actor *)jarg3;
70404   if (!argp3) {
70405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70406     return ;
70407   }
70408   arg3 = *argp3;
70409   {
70410     try {
70411       (arg1)->ItemReleased(arg2,arg3);
70412     } catch (std::out_of_range& e) {
70413       {
70414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70415       };
70416     } catch (std::exception& e) {
70417       {
70418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70419       };
70420     } catch (Dali::DaliException e) {
70421       {
70422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70423       };
70424     } catch (...) {
70425       {
70426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70427       };
70428     }
70429   }
70430
70431 }
70432
70433
70434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70435   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70436   unsigned int arg2 ;
70437   Dali::Actor arg3 ;
70438   Dali::Actor *argp3 ;
70439
70440   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70441   arg2 = (unsigned int)jarg2;
70442   argp3 = (Dali::Actor *)jarg3;
70443   if (!argp3) {
70444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70445     return ;
70446   }
70447   arg3 = *argp3;
70448   {
70449     try {
70450       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70451     } catch (std::out_of_range& e) {
70452       {
70453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70454       };
70455     } catch (std::exception& e) {
70456       {
70457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70458       };
70459     } catch (Dali::DaliException e) {
70460       {
70461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70462       };
70463     } catch (...) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70466       };
70467     }
70468   }
70469
70470 }
70471
70472
70473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70474   void * jresult ;
70475   Dali::Toolkit::ItemFactory *result = 0 ;
70476
70477   {
70478     try {
70479       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70480     } catch (std::out_of_range& e) {
70481       {
70482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70483       };
70484     } catch (std::exception& e) {
70485       {
70486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70487       };
70488     } catch (Dali::DaliException e) {
70489       {
70490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70491       };
70492     } catch (...) {
70493       {
70494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70495       };
70496     }
70497   }
70498
70499   jresult = (void *)result;
70500   return jresult;
70501 }
70502
70503
70504 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) {
70505   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70506   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70507   if (director) {
70508     director->swig_connect_director(callback0, callback1, callback2);
70509   }
70510 }
70511
70512
70513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70514   int jresult ;
70515   int result;
70516
70517   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70518   jresult = (int)result;
70519   return jresult;
70520 }
70521
70522
70523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70524   int jresult ;
70525   int result;
70526
70527   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70528   jresult = (int)result;
70529   return jresult;
70530 }
70531
70532
70533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70534   int jresult ;
70535   int result;
70536
70537   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70538   jresult = (int)result;
70539   return jresult;
70540 }
70541
70542
70543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70544   int jresult ;
70545   int result;
70546
70547   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70548   jresult = (int)result;
70549   return jresult;
70550 }
70551
70552
70553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70554   int jresult ;
70555   int result;
70556
70557   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70558   jresult = (int)result;
70559   return jresult;
70560 }
70561
70562
70563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70564   int jresult ;
70565   int result;
70566
70567   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70568   jresult = (int)result;
70569   return jresult;
70570 }
70571
70572
70573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70574   int jresult ;
70575   int result;
70576
70577   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70578   jresult = (int)result;
70579   return jresult;
70580 }
70581
70582
70583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70584   int jresult ;
70585   int result;
70586
70587   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70588   jresult = (int)result;
70589   return jresult;
70590 }
70591
70592
70593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70594   int jresult ;
70595   int result;
70596
70597   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70598   jresult = (int)result;
70599   return jresult;
70600 }
70601
70602
70603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70604   int jresult ;
70605   int result;
70606
70607   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70608   jresult = (int)result;
70609   return jresult;
70610 }
70611
70612
70613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70614   int jresult ;
70615   int result;
70616
70617   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70618   jresult = (int)result;
70619   return jresult;
70620 }
70621
70622
70623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70624   void * jresult ;
70625   Dali::Toolkit::ItemView::Property *result = 0 ;
70626
70627   {
70628     try {
70629       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70630     } catch (std::out_of_range& e) {
70631       {
70632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (std::exception& e) {
70635       {
70636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70637       };
70638     } catch (Dali::DaliException e) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70641       };
70642     } catch (...) {
70643       {
70644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70645       };
70646     }
70647   }
70648
70649   jresult = (void *)result;
70650   return jresult;
70651 }
70652
70653
70654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70655   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70656
70657   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70658   {
70659     try {
70660       delete arg1;
70661     } catch (std::out_of_range& e) {
70662       {
70663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70664       };
70665     } catch (std::exception& e) {
70666       {
70667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70668       };
70669     } catch (Dali::DaliException e) {
70670       {
70671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70672       };
70673     } catch (...) {
70674       {
70675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70676       };
70677     }
70678   }
70679
70680 }
70681
70682
70683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70684   void * jresult ;
70685   Dali::Toolkit::ItemView *result = 0 ;
70686
70687   {
70688     try {
70689       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70690     } catch (std::out_of_range& e) {
70691       {
70692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70693       };
70694     } catch (std::exception& e) {
70695       {
70696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70697       };
70698     } catch (Dali::DaliException e) {
70699       {
70700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70701       };
70702     } catch (...) {
70703       {
70704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70705       };
70706     }
70707   }
70708
70709   jresult = (void *)result;
70710   return jresult;
70711 }
70712
70713
70714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70715   void * jresult ;
70716   Dali::Toolkit::ItemView *arg1 = 0 ;
70717   Dali::Toolkit::ItemView *result = 0 ;
70718
70719   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70720   if (!arg1) {
70721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70722     return 0;
70723   }
70724   {
70725     try {
70726       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70727     } catch (std::out_of_range& e) {
70728       {
70729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70730       };
70731     } catch (std::exception& e) {
70732       {
70733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70734       };
70735     } catch (Dali::DaliException e) {
70736       {
70737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70738       };
70739     } catch (...) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70742       };
70743     }
70744   }
70745
70746   jresult = (void *)result;
70747   return jresult;
70748 }
70749
70750
70751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70752   void * jresult ;
70753   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70754   Dali::Toolkit::ItemView *arg2 = 0 ;
70755   Dali::Toolkit::ItemView *result = 0 ;
70756
70757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70758   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70759   if (!arg2) {
70760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70761     return 0;
70762   }
70763   {
70764     try {
70765       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70766     } catch (std::out_of_range& e) {
70767       {
70768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70769       };
70770     } catch (std::exception& e) {
70771       {
70772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70773       };
70774     } catch (Dali::DaliException e) {
70775       {
70776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70777       };
70778     } catch (...) {
70779       {
70780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70781       };
70782     }
70783   }
70784
70785   jresult = (void *)result;
70786   return jresult;
70787 }
70788
70789
70790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70791   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70792
70793   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70794   {
70795     try {
70796       delete arg1;
70797     } catch (std::out_of_range& e) {
70798       {
70799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70800       };
70801     } catch (std::exception& e) {
70802       {
70803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70804       };
70805     } catch (Dali::DaliException e) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70808       };
70809     } catch (...) {
70810       {
70811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70812       };
70813     }
70814   }
70815
70816 }
70817
70818
70819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70820   void * jresult ;
70821   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70822   Dali::Toolkit::ItemView result;
70823
70824   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70825   if (!arg1) {
70826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70827     return 0;
70828   }
70829   {
70830     try {
70831       result = Dali::Toolkit::ItemView::New(*arg1);
70832     } catch (std::out_of_range& e) {
70833       {
70834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70835       };
70836     } catch (std::exception& e) {
70837       {
70838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (Dali::DaliException e) {
70841       {
70842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70843       };
70844     } catch (...) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70847       };
70848     }
70849   }
70850
70851   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70852   return jresult;
70853 }
70854
70855
70856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70857   void * jresult ;
70858   Dali::BaseHandle arg1 ;
70859   Dali::BaseHandle *argp1 ;
70860   Dali::Toolkit::ItemView result;
70861
70862   argp1 = (Dali::BaseHandle *)jarg1;
70863   if (!argp1) {
70864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70865     return 0;
70866   }
70867   arg1 = *argp1;
70868   {
70869     try {
70870       result = Dali::Toolkit::ItemView::DownCast(arg1);
70871     } catch (std::out_of_range& e) {
70872       {
70873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (std::exception& e) {
70876       {
70877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (Dali::DaliException e) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70882       };
70883     } catch (...) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70886       };
70887     }
70888   }
70889
70890   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70891   return jresult;
70892 }
70893
70894
70895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70896   unsigned int jresult ;
70897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70898   unsigned int result;
70899
70900   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70901   {
70902     try {
70903       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70904     } catch (std::out_of_range& e) {
70905       {
70906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70907       };
70908     } catch (std::exception& e) {
70909       {
70910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70911       };
70912     } catch (Dali::DaliException e) {
70913       {
70914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70915       };
70916     } catch (...) {
70917       {
70918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70919       };
70920     }
70921   }
70922
70923   jresult = result;
70924   return jresult;
70925 }
70926
70927
70928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70929   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70930   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70931
70932   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70933   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70934   if (!arg2) {
70935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70936     return ;
70937   }
70938   {
70939     try {
70940       (arg1)->AddLayout(*arg2);
70941     } catch (std::out_of_range& e) {
70942       {
70943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70944       };
70945     } catch (std::exception& e) {
70946       {
70947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70948       };
70949     } catch (Dali::DaliException e) {
70950       {
70951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70952       };
70953     } catch (...) {
70954       {
70955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70956       };
70957     }
70958   }
70959
70960 }
70961
70962
70963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70964   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70965   unsigned int arg2 ;
70966
70967   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70968   arg2 = (unsigned int)jarg2;
70969   {
70970     try {
70971       (arg1)->RemoveLayout(arg2);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70987       };
70988     }
70989   }
70990
70991 }
70992
70993
70994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70995   void * jresult ;
70996   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70997   unsigned int arg2 ;
70998   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70999
71000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71001   arg2 = (unsigned int)jarg2;
71002   {
71003     try {
71004       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71005     } catch (std::out_of_range& e) {
71006       {
71007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71008       };
71009     } catch (std::exception& e) {
71010       {
71011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71012       };
71013     } catch (Dali::DaliException e) {
71014       {
71015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71016       };
71017     } catch (...) {
71018       {
71019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71020       };
71021     }
71022   }
71023
71024   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71025   return jresult;
71026 }
71027
71028
71029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71030   void * jresult ;
71031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71032   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71033
71034   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71035   {
71036     try {
71037       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71038     } catch (std::out_of_range& e) {
71039       {
71040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (std::exception& e) {
71043       {
71044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (Dali::DaliException e) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71049       };
71050     } catch (...) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71053       };
71054     }
71055   }
71056
71057   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71058   return jresult;
71059 }
71060
71061
71062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71063   float jresult ;
71064   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71065   Dali::Toolkit::ItemId arg2 ;
71066   float result;
71067
71068   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71069   arg2 = (Dali::Toolkit::ItemId)jarg2;
71070   {
71071     try {
71072       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71073     } catch (std::out_of_range& e) {
71074       {
71075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71076       };
71077     } catch (std::exception& e) {
71078       {
71079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71080       };
71081     } catch (Dali::DaliException e) {
71082       {
71083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71084       };
71085     } catch (...) {
71086       {
71087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71088       };
71089     }
71090   }
71091
71092   jresult = result;
71093   return jresult;
71094 }
71095
71096
71097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71098   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71099   unsigned int arg2 ;
71100   Dali::Vector3 arg3 ;
71101   float arg4 ;
71102   Dali::Vector3 *argp3 ;
71103
71104   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71105   arg2 = (unsigned int)jarg2;
71106   argp3 = (Dali::Vector3 *)jarg3;
71107   if (!argp3) {
71108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71109     return ;
71110   }
71111   arg3 = *argp3;
71112   arg4 = (float)jarg4;
71113   {
71114     try {
71115       (arg1)->ActivateLayout(arg2,arg3,arg4);
71116     } catch (std::out_of_range& e) {
71117       {
71118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71119       };
71120     } catch (std::exception& e) {
71121       {
71122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71123       };
71124     } catch (Dali::DaliException e) {
71125       {
71126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71127       };
71128     } catch (...) {
71129       {
71130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71131       };
71132     }
71133   }
71134
71135 }
71136
71137
71138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71139   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71140
71141   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71142   {
71143     try {
71144       (arg1)->DeactivateCurrentLayout();
71145     } catch (std::out_of_range& e) {
71146       {
71147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71148       };
71149     } catch (std::exception& e) {
71150       {
71151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71152       };
71153     } catch (Dali::DaliException e) {
71154       {
71155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71156       };
71157     } catch (...) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71160       };
71161     }
71162   }
71163
71164 }
71165
71166
71167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71168   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71169   float arg2 ;
71170
71171   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71172   arg2 = (float)jarg2;
71173   {
71174     try {
71175       (arg1)->SetMinimumSwipeSpeed(arg2);
71176     } catch (std::out_of_range& e) {
71177       {
71178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71179       };
71180     } catch (std::exception& e) {
71181       {
71182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71183       };
71184     } catch (Dali::DaliException e) {
71185       {
71186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71187       };
71188     } catch (...) {
71189       {
71190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71191       };
71192     }
71193   }
71194
71195 }
71196
71197
71198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71199   float jresult ;
71200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71201   float result;
71202
71203   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71204   {
71205     try {
71206       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71207     } catch (std::out_of_range& e) {
71208       {
71209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (std::exception& e) {
71212       {
71213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71214       };
71215     } catch (Dali::DaliException e) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71218       };
71219     } catch (...) {
71220       {
71221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71222       };
71223     }
71224   }
71225
71226   jresult = result;
71227   return jresult;
71228 }
71229
71230
71231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71232   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71233   float arg2 ;
71234
71235   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71236   arg2 = (float)jarg2;
71237   {
71238     try {
71239       (arg1)->SetMinimumSwipeDistance(arg2);
71240     } catch (std::out_of_range& e) {
71241       {
71242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71243       };
71244     } catch (std::exception& e) {
71245       {
71246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71247       };
71248     } catch (Dali::DaliException e) {
71249       {
71250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71251       };
71252     } catch (...) {
71253       {
71254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71255       };
71256     }
71257   }
71258
71259 }
71260
71261
71262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71263   float jresult ;
71264   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71265   float result;
71266
71267   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71268   {
71269     try {
71270       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71271     } catch (std::out_of_range& e) {
71272       {
71273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71274       };
71275     } catch (std::exception& e) {
71276       {
71277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71278       };
71279     } catch (Dali::DaliException e) {
71280       {
71281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71282       };
71283     } catch (...) {
71284       {
71285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71286       };
71287     }
71288   }
71289
71290   jresult = result;
71291   return jresult;
71292 }
71293
71294
71295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71296   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71297   float arg2 ;
71298
71299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71300   arg2 = (float)jarg2;
71301   {
71302     try {
71303       (arg1)->SetWheelScrollDistanceStep(arg2);
71304     } catch (std::out_of_range& e) {
71305       {
71306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71307       };
71308     } catch (std::exception& e) {
71309       {
71310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71311       };
71312     } catch (Dali::DaliException e) {
71313       {
71314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71315       };
71316     } catch (...) {
71317       {
71318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71319       };
71320     }
71321   }
71322
71323 }
71324
71325
71326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71327   float jresult ;
71328   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71329   float result;
71330
71331   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71332   {
71333     try {
71334       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71335     } catch (std::out_of_range& e) {
71336       {
71337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (std::exception& e) {
71340       {
71341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71342       };
71343     } catch (Dali::DaliException e) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71346       };
71347     } catch (...) {
71348       {
71349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71350       };
71351     }
71352   }
71353
71354   jresult = result;
71355   return jresult;
71356 }
71357
71358
71359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71360   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71361   bool arg2 ;
71362
71363   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71364   arg2 = jarg2 ? true : false;
71365   {
71366     try {
71367       (arg1)->SetAnchoring(arg2);
71368     } catch (std::out_of_range& e) {
71369       {
71370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71371       };
71372     } catch (std::exception& e) {
71373       {
71374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71375       };
71376     } catch (Dali::DaliException e) {
71377       {
71378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71379       };
71380     } catch (...) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71383       };
71384     }
71385   }
71386
71387 }
71388
71389 //// ========================= end of part 3 =============================
71390
71391 //// ========================== start part 4 ===============================
71392
71393
71394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71395   unsigned int jresult ;
71396   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71397   bool result;
71398
71399   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71400   {
71401     try {
71402       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71403     } catch (std::out_of_range& e) {
71404       {
71405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71406       };
71407     } catch (std::exception& e) {
71408       {
71409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71410       };
71411     } catch (Dali::DaliException e) {
71412       {
71413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71414       };
71415     } catch (...) {
71416       {
71417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71418       };
71419     }
71420   }
71421
71422   jresult = result;
71423   return jresult;
71424 }
71425
71426
71427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71428   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71429   float arg2 ;
71430
71431   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71432   arg2 = (float)jarg2;
71433   {
71434     try {
71435       (arg1)->SetAnchoringDuration(arg2);
71436     } catch (std::out_of_range& e) {
71437       {
71438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71439       };
71440     } catch (std::exception& e) {
71441       {
71442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71443       };
71444     } catch (Dali::DaliException e) {
71445       {
71446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71447       };
71448     } catch (...) {
71449       {
71450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71451       };
71452     }
71453   }
71454
71455 }
71456
71457
71458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71459   float jresult ;
71460   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71461   float result;
71462
71463   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71464   {
71465     try {
71466       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71467     } catch (std::out_of_range& e) {
71468       {
71469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71470       };
71471     } catch (std::exception& e) {
71472       {
71473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71474       };
71475     } catch (Dali::DaliException e) {
71476       {
71477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71478       };
71479     } catch (...) {
71480       {
71481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71482       };
71483     }
71484   }
71485
71486   jresult = result;
71487   return jresult;
71488 }
71489
71490
71491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71492   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71493   Dali::Toolkit::ItemId arg2 ;
71494   float arg3 ;
71495
71496   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71497   arg2 = (Dali::Toolkit::ItemId)jarg2;
71498   arg3 = (float)jarg3;
71499   {
71500     try {
71501       (arg1)->ScrollToItem(arg2,arg3);
71502     } catch (std::out_of_range& e) {
71503       {
71504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71505       };
71506     } catch (std::exception& e) {
71507       {
71508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71509       };
71510     } catch (Dali::DaliException e) {
71511       {
71512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71513       };
71514     } catch (...) {
71515       {
71516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71517       };
71518     }
71519   }
71520
71521 }
71522
71523
71524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71525   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71526   float arg2 ;
71527
71528   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71529   arg2 = (float)jarg2;
71530   {
71531     try {
71532       (arg1)->SetRefreshInterval(arg2);
71533     } catch (std::out_of_range& e) {
71534       {
71535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (std::exception& e) {
71538       {
71539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71540       };
71541     } catch (Dali::DaliException e) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71544       };
71545     } catch (...) {
71546       {
71547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71548       };
71549     }
71550   }
71551
71552 }
71553
71554
71555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71556   float jresult ;
71557   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71558   float result;
71559
71560   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71561   {
71562     try {
71563       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71564     } catch (std::out_of_range& e) {
71565       {
71566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71567       };
71568     } catch (std::exception& e) {
71569       {
71570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71571       };
71572     } catch (Dali::DaliException e) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71575       };
71576     } catch (...) {
71577       {
71578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71579       };
71580     }
71581   }
71582
71583   jresult = result;
71584   return jresult;
71585 }
71586
71587
71588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71589   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71590
71591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71592   {
71593     try {
71594       (arg1)->Refresh();
71595     } catch (std::out_of_range& e) {
71596       {
71597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71598       };
71599     } catch (std::exception& e) {
71600       {
71601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71602       };
71603     } catch (Dali::DaliException e) {
71604       {
71605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71606       };
71607     } catch (...) {
71608       {
71609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71610       };
71611     }
71612   }
71613
71614 }
71615
71616
71617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71618   void * jresult ;
71619   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71620   Dali::Toolkit::ItemId arg2 ;
71621   Dali::Actor result;
71622
71623   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71624   arg2 = (Dali::Toolkit::ItemId)jarg2;
71625   {
71626     try {
71627       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71628     } catch (std::out_of_range& e) {
71629       {
71630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71631       };
71632     } catch (std::exception& e) {
71633       {
71634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (Dali::DaliException e) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71639       };
71640     } catch (...) {
71641       {
71642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71643       };
71644     }
71645   }
71646
71647   jresult = new Dali::Actor((const Dali::Actor &)result);
71648   return jresult;
71649 }
71650
71651
71652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71653   unsigned int jresult ;
71654   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71655   Dali::Actor arg2 ;
71656   Dali::Actor *argp2 ;
71657   Dali::Toolkit::ItemId result;
71658
71659   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71660   argp2 = (Dali::Actor *)jarg2;
71661   if (!argp2) {
71662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71663     return 0;
71664   }
71665   arg2 = *argp2;
71666   {
71667     try {
71668       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71669     } catch (std::out_of_range& e) {
71670       {
71671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71672       };
71673     } catch (std::exception& e) {
71674       {
71675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71676       };
71677     } catch (Dali::DaliException e) {
71678       {
71679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71684       };
71685     }
71686   }
71687
71688   jresult = result;
71689   return jresult;
71690 }
71691
71692
71693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71694   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71695   Dali::Toolkit::Item arg2 ;
71696   float arg3 ;
71697   Dali::Toolkit::Item *argp2 ;
71698
71699   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71700   argp2 = (Dali::Toolkit::Item *)jarg2;
71701   if (!argp2) {
71702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71703     return ;
71704   }
71705   arg2 = *argp2;
71706   arg3 = (float)jarg3;
71707   {
71708     try {
71709       (arg1)->InsertItem(arg2,arg3);
71710     } catch (std::out_of_range& e) {
71711       {
71712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71713       };
71714     } catch (std::exception& e) {
71715       {
71716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71717       };
71718     } catch (Dali::DaliException e) {
71719       {
71720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71721       };
71722     } catch (...) {
71723       {
71724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71725       };
71726     }
71727   }
71728
71729 }
71730
71731
71732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71734   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71735   float arg3 ;
71736
71737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71738   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71739   if (!arg2) {
71740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71741     return ;
71742   }
71743   arg3 = (float)jarg3;
71744   {
71745     try {
71746       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71747     } catch (std::out_of_range& e) {
71748       {
71749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71750       };
71751     } catch (std::exception& e) {
71752       {
71753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71754       };
71755     } catch (Dali::DaliException e) {
71756       {
71757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71758       };
71759     } catch (...) {
71760       {
71761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71762       };
71763     }
71764   }
71765
71766 }
71767
71768
71769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71770   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71771   Dali::Toolkit::ItemId arg2 ;
71772   float arg3 ;
71773
71774   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71775   arg2 = (Dali::Toolkit::ItemId)jarg2;
71776   arg3 = (float)jarg3;
71777   {
71778     try {
71779       (arg1)->RemoveItem(arg2,arg3);
71780     } catch (std::out_of_range& e) {
71781       {
71782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71783       };
71784     } catch (std::exception& e) {
71785       {
71786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71787       };
71788     } catch (Dali::DaliException e) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71791       };
71792     } catch (...) {
71793       {
71794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71795       };
71796     }
71797   }
71798
71799 }
71800
71801
71802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71803   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71804   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71805   float arg3 ;
71806
71807   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71808   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71809   if (!arg2) {
71810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71811     return ;
71812   }
71813   arg3 = (float)jarg3;
71814   {
71815     try {
71816       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71817     } catch (std::out_of_range& e) {
71818       {
71819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71820       };
71821     } catch (std::exception& e) {
71822       {
71823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71824       };
71825     } catch (Dali::DaliException e) {
71826       {
71827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71828       };
71829     } catch (...) {
71830       {
71831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71832       };
71833     }
71834   }
71835
71836 }
71837
71838
71839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71840   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71841   Dali::Toolkit::Item arg2 ;
71842   float arg3 ;
71843   Dali::Toolkit::Item *argp2 ;
71844
71845   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71846   argp2 = (Dali::Toolkit::Item *)jarg2;
71847   if (!argp2) {
71848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71849     return ;
71850   }
71851   arg2 = *argp2;
71852   arg3 = (float)jarg3;
71853   {
71854     try {
71855       (arg1)->ReplaceItem(arg2,arg3);
71856     } catch (std::out_of_range& e) {
71857       {
71858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71859       };
71860     } catch (std::exception& e) {
71861       {
71862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71863       };
71864     } catch (Dali::DaliException e) {
71865       {
71866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71867       };
71868     } catch (...) {
71869       {
71870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71871       };
71872     }
71873   }
71874
71875 }
71876
71877
71878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71879   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71880   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71881   float arg3 ;
71882
71883   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71884   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71885   if (!arg2) {
71886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71887     return ;
71888   }
71889   arg3 = (float)jarg3;
71890   {
71891     try {
71892       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71893     } catch (std::out_of_range& e) {
71894       {
71895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (std::exception& e) {
71898       {
71899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71900       };
71901     } catch (Dali::DaliException e) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71904       };
71905     } catch (...) {
71906       {
71907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71908       };
71909     }
71910   }
71911
71912 }
71913
71914
71915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71917   Dali::Vector3 *arg2 = 0 ;
71918
71919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71920   arg2 = (Dali::Vector3 *)jarg2;
71921   if (!arg2) {
71922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71923     return ;
71924   }
71925   {
71926     try {
71927       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71928     } catch (std::out_of_range& e) {
71929       {
71930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71931       };
71932     } catch (std::exception& e) {
71933       {
71934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71935       };
71936     } catch (Dali::DaliException e) {
71937       {
71938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71939       };
71940     } catch (...) {
71941       {
71942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71943       };
71944     }
71945   }
71946
71947 }
71948
71949
71950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71951   void * jresult ;
71952   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71953   Dali::Vector3 result;
71954
71955   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71956   {
71957     try {
71958       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71959     } catch (std::out_of_range& e) {
71960       {
71961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71962       };
71963     } catch (std::exception& e) {
71964       {
71965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71966       };
71967     } catch (Dali::DaliException e) {
71968       {
71969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71970       };
71971     } catch (...) {
71972       {
71973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71974       };
71975     }
71976   }
71977
71978   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71979   return jresult;
71980 }
71981
71982
71983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71984   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71985   Dali::Vector3 *arg2 = 0 ;
71986
71987   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71988   arg2 = (Dali::Vector3 *)jarg2;
71989   if (!arg2) {
71990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71991     return ;
71992   }
71993   {
71994     try {
71995       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71996     } catch (std::out_of_range& e) {
71997       {
71998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71999       };
72000     } catch (std::exception& e) {
72001       {
72002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72003       };
72004     } catch (Dali::DaliException e) {
72005       {
72006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72007       };
72008     } catch (...) {
72009       {
72010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72011       };
72012     }
72013   }
72014
72015 }
72016
72017
72018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72019   void * jresult ;
72020   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72021   Dali::Vector3 result;
72022
72023   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72024   {
72025     try {
72026       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72027     } catch (std::out_of_range& e) {
72028       {
72029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72030       };
72031     } catch (std::exception& e) {
72032       {
72033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72034       };
72035     } catch (Dali::DaliException e) {
72036       {
72037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72038       };
72039     } catch (...) {
72040       {
72041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72042       };
72043     }
72044   }
72045
72046   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72047   return jresult;
72048 }
72049
72050
72051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72052   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72053   Dali::Toolkit::ItemRange *arg2 = 0 ;
72054
72055   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72056   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72057   if (!arg2) {
72058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72059     return ;
72060   }
72061   {
72062     try {
72063       (arg1)->GetItemsRange(*arg2);
72064     } catch (std::out_of_range& e) {
72065       {
72066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72067       };
72068     } catch (std::exception& e) {
72069       {
72070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72071       };
72072     } catch (Dali::DaliException e) {
72073       {
72074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72075       };
72076     } catch (...) {
72077       {
72078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72079       };
72080     }
72081   }
72082
72083 }
72084
72085
72086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72087   void * jresult ;
72088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72089   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72090
72091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72092   {
72093     try {
72094       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72095     } catch (std::out_of_range& e) {
72096       {
72097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72098       };
72099     } catch (std::exception& e) {
72100       {
72101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72102       };
72103     } catch (Dali::DaliException e) {
72104       {
72105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72106       };
72107     } catch (...) {
72108       {
72109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72110       };
72111     }
72112   }
72113
72114   jresult = (void *)result;
72115   return jresult;
72116 }
72117
72118
72119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72120   Dali::Vector3 *arg1 = 0 ;
72121   PropertyInputContainer *arg2 = 0 ;
72122
72123   arg1 = (Dali::Vector3 *)jarg1;
72124   if (!arg1) {
72125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72126     return ;
72127   }
72128   arg2 = (PropertyInputContainer *)jarg2;
72129   if (!arg2) {
72130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72131     return ;
72132   }
72133   {
72134     try {
72135       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72136     } catch (std::out_of_range& e) {
72137       {
72138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72139       };
72140     } catch (std::exception& e) {
72141       {
72142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72143       };
72144     } catch (Dali::DaliException e) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72147       };
72148     } catch (...) {
72149       {
72150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72151       };
72152     }
72153   }
72154
72155 }
72156
72157
72158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72159   Dali::Vector3 *arg1 = 0 ;
72160   PropertyInputContainer *arg2 = 0 ;
72161
72162   arg1 = (Dali::Vector3 *)jarg1;
72163   if (!arg1) {
72164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72165     return ;
72166   }
72167   arg2 = (PropertyInputContainer *)jarg2;
72168   if (!arg2) {
72169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72170     return ;
72171   }
72172   {
72173     try {
72174       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (Dali::DaliException e) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72186       };
72187     } catch (...) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72190       };
72191     }
72192   }
72193
72194 }
72195
72196
72197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72198   void * jresult ;
72199   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72200
72201   {
72202     try {
72203       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72204     } catch (std::out_of_range& e) {
72205       {
72206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72207       };
72208     } catch (std::exception& e) {
72209       {
72210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72211       };
72212     } catch (Dali::DaliException e) {
72213       {
72214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72215       };
72216     } catch (...) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72219       };
72220     }
72221   }
72222
72223   jresult = (void *)result;
72224   return jresult;
72225 }
72226
72227
72228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72229   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72230
72231   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72232   {
72233     try {
72234       delete arg1;
72235     } catch (std::out_of_range& e) {
72236       {
72237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72238       };
72239     } catch (std::exception& e) {
72240       {
72241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72242       };
72243     } catch (Dali::DaliException e) {
72244       {
72245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72246       };
72247     } catch (...) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72250       };
72251     }
72252   }
72253
72254 }
72255
72256
72257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72258   void * jresult ;
72259   Dali::Path arg1 ;
72260   Dali::Vector3 *arg2 = 0 ;
72261   Dali::Property::Index arg3 ;
72262   Dali::Vector3 *arg4 = 0 ;
72263   unsigned int arg5 ;
72264   Dali::Path *argp1 ;
72265   Dali::Toolkit::ScrollViewPagePathEffect result;
72266
72267   argp1 = (Dali::Path *)jarg1;
72268   if (!argp1) {
72269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72270     return 0;
72271   }
72272   arg1 = *argp1;
72273   arg2 = (Dali::Vector3 *)jarg2;
72274   if (!arg2) {
72275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72276     return 0;
72277   }
72278   arg3 = (Dali::Property::Index)jarg3;
72279   arg4 = (Dali::Vector3 *)jarg4;
72280   if (!arg4) {
72281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72282     return 0;
72283   }
72284   arg5 = (unsigned int)jarg5;
72285   {
72286     try {
72287       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72288     } catch (std::out_of_range& e) {
72289       {
72290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72291       };
72292     } catch (std::exception& e) {
72293       {
72294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72295       };
72296     } catch (Dali::DaliException e) {
72297       {
72298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72299       };
72300     } catch (...) {
72301       {
72302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72303       };
72304     }
72305   }
72306
72307   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72308   return jresult;
72309 }
72310
72311
72312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72313   void * jresult ;
72314   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72315
72316   {
72317     try {
72318       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72319     } catch (std::out_of_range& e) {
72320       {
72321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72322       };
72323     } catch (std::exception& e) {
72324       {
72325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72326       };
72327     } catch (Dali::DaliException e) {
72328       {
72329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72330       };
72331     } catch (...) {
72332       {
72333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72334       };
72335     }
72336   }
72337
72338   jresult = (void *)result;
72339   return jresult;
72340 }
72341
72342
72343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72344   void * jresult ;
72345   Dali::BaseHandle arg1 ;
72346   Dali::BaseHandle *argp1 ;
72347   Dali::Toolkit::ScrollViewPagePathEffect result;
72348
72349   argp1 = (Dali::BaseHandle *)jarg1;
72350   if (!argp1) {
72351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72352     return 0;
72353   }
72354   arg1 = *argp1;
72355   {
72356     try {
72357       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72358     } catch (std::out_of_range& e) {
72359       {
72360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72361       };
72362     } catch (std::exception& e) {
72363       {
72364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72365       };
72366     } catch (Dali::DaliException e) {
72367       {
72368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72369       };
72370     } catch (...) {
72371       {
72372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72373       };
72374     }
72375   }
72376
72377   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72383   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72384   Dali::Actor arg2 ;
72385   unsigned int arg3 ;
72386   Dali::Actor *argp2 ;
72387
72388   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72389   argp2 = (Dali::Actor *)jarg2;
72390   if (!argp2) {
72391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72392     return ;
72393   }
72394   arg2 = *argp2;
72395   arg3 = (unsigned int)jarg3;
72396   {
72397     try {
72398       (arg1)->ApplyToPage(arg2,arg3);
72399     } catch (std::out_of_range& e) {
72400       {
72401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72402       };
72403     } catch (std::exception& e) {
72404       {
72405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72406       };
72407     } catch (Dali::DaliException e) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72410       };
72411     } catch (...) {
72412       {
72413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72414       };
72415     }
72416   }
72417
72418 }
72419
72420
72421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72422   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72423
72424   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72425   {
72426     try {
72427       delete arg1;
72428     } catch (std::out_of_range& e) {
72429       {
72430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72431       };
72432     } catch (std::exception& e) {
72433       {
72434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72435       };
72436     } catch (Dali::DaliException e) {
72437       {
72438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72439       };
72440     } catch (...) {
72441       {
72442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72443       };
72444     }
72445   }
72446
72447 }
72448
72449
72450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72451   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72452   Dali::Toolkit::ClampState arg2 ;
72453
72454   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72455   arg2 = (Dali::Toolkit::ClampState)jarg2;
72456   if (arg1) (arg1)->x = arg2;
72457 }
72458
72459
72460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72461   int jresult ;
72462   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72463   Dali::Toolkit::ClampState result;
72464
72465   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72466   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72467   jresult = (int)result;
72468   return jresult;
72469 }
72470
72471
72472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72473   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72474   Dali::Toolkit::ClampState arg2 ;
72475
72476   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72477   arg2 = (Dali::Toolkit::ClampState)jarg2;
72478   if (arg1) (arg1)->y = arg2;
72479 }
72480
72481
72482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72483   int jresult ;
72484   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72485   Dali::Toolkit::ClampState result;
72486
72487   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72488   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72489   jresult = (int)result;
72490   return jresult;
72491 }
72492
72493
72494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72495   void * jresult ;
72496   Dali::Toolkit::ClampState2D *result = 0 ;
72497
72498   {
72499     try {
72500       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72501     } catch (std::out_of_range& e) {
72502       {
72503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72504       };
72505     } catch (std::exception& e) {
72506       {
72507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72508       };
72509     } catch (Dali::DaliException e) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72512       };
72513     } catch (...) {
72514       {
72515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72516       };
72517     }
72518   }
72519
72520   jresult = (void *)result;
72521   return jresult;
72522 }
72523
72524
72525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72526   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72527
72528   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72529   {
72530     try {
72531       delete arg1;
72532     } catch (std::out_of_range& e) {
72533       {
72534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72535       };
72536     } catch (std::exception& e) {
72537       {
72538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72539       };
72540     } catch (Dali::DaliException e) {
72541       {
72542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72543       };
72544     } catch (...) {
72545       {
72546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72547       };
72548     }
72549   }
72550
72551 }
72552
72553
72554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72555   void * jresult ;
72556   float arg1 ;
72557   float arg2 ;
72558   bool arg3 ;
72559   Dali::Toolkit::RulerDomain *result = 0 ;
72560
72561   arg1 = (float)jarg1;
72562   arg2 = (float)jarg2;
72563   arg3 = jarg3 ? true : false;
72564   {
72565     try {
72566       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72567     } catch (std::out_of_range& e) {
72568       {
72569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72570       };
72571     } catch (std::exception& e) {
72572       {
72573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72574       };
72575     } catch (Dali::DaliException e) {
72576       {
72577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72578       };
72579     } catch (...) {
72580       {
72581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72582       };
72583     }
72584   }
72585
72586   jresult = (void *)result;
72587   return jresult;
72588 }
72589
72590
72591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72592   void * jresult ;
72593   float arg1 ;
72594   float arg2 ;
72595   Dali::Toolkit::RulerDomain *result = 0 ;
72596
72597   arg1 = (float)jarg1;
72598   arg2 = (float)jarg2;
72599   {
72600     try {
72601       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72602     } catch (std::out_of_range& e) {
72603       {
72604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72605       };
72606     } catch (std::exception& e) {
72607       {
72608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72609       };
72610     } catch (Dali::DaliException e) {
72611       {
72612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72613       };
72614     } catch (...) {
72615       {
72616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72617       };
72618     }
72619   }
72620
72621   jresult = (void *)result;
72622   return jresult;
72623 }
72624
72625
72626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72627   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72628   float arg2 ;
72629
72630   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72631   arg2 = (float)jarg2;
72632   if (arg1) (arg1)->min = arg2;
72633 }
72634
72635
72636 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72637   float jresult ;
72638   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72639   float result;
72640
72641   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72642   result = (float) ((arg1)->min);
72643   jresult = result;
72644   return jresult;
72645 }
72646
72647
72648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72649   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72650   float arg2 ;
72651
72652   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72653   arg2 = (float)jarg2;
72654   if (arg1) (arg1)->max = arg2;
72655 }
72656
72657
72658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72659   float jresult ;
72660   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72661   float result;
72662
72663   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72664   result = (float) ((arg1)->max);
72665   jresult = result;
72666   return jresult;
72667 }
72668
72669
72670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72671   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72672   bool arg2 ;
72673
72674   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72675   arg2 = jarg2 ? true : false;
72676   if (arg1) (arg1)->enabled = arg2;
72677 }
72678
72679
72680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72681   unsigned int jresult ;
72682   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72683   bool result;
72684
72685   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72686   result = (bool) ((arg1)->enabled);
72687   jresult = result;
72688   return jresult;
72689 }
72690
72691
72692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72693   float jresult ;
72694   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72695   float arg2 ;
72696   float arg3 ;
72697   float arg4 ;
72698   float result;
72699
72700   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72701   arg2 = (float)jarg2;
72702   arg3 = (float)jarg3;
72703   arg4 = (float)jarg4;
72704   {
72705     try {
72706       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72707     } catch (std::out_of_range& e) {
72708       {
72709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72710       };
72711     } catch (std::exception& e) {
72712       {
72713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72714       };
72715     } catch (Dali::DaliException e) {
72716       {
72717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72718       };
72719     } catch (...) {
72720       {
72721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72722       };
72723     }
72724   }
72725
72726   jresult = result;
72727   return jresult;
72728 }
72729
72730
72731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72732   float jresult ;
72733   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72734   float arg2 ;
72735   float arg3 ;
72736   float result;
72737
72738   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72739   arg2 = (float)jarg2;
72740   arg3 = (float)jarg3;
72741   {
72742     try {
72743       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72744     } catch (std::out_of_range& e) {
72745       {
72746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72747       };
72748     } catch (std::exception& e) {
72749       {
72750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72751       };
72752     } catch (Dali::DaliException e) {
72753       {
72754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72755       };
72756     } catch (...) {
72757       {
72758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72759       };
72760     }
72761   }
72762
72763   jresult = result;
72764   return jresult;
72765 }
72766
72767
72768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72769   float jresult ;
72770   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72771   float arg2 ;
72772   float result;
72773
72774   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72775   arg2 = (float)jarg2;
72776   {
72777     try {
72778       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72779     } catch (std::out_of_range& e) {
72780       {
72781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72782       };
72783     } catch (std::exception& e) {
72784       {
72785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72786       };
72787     } catch (Dali::DaliException e) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72790       };
72791     } catch (...) {
72792       {
72793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72794       };
72795     }
72796   }
72797
72798   jresult = result;
72799   return jresult;
72800 }
72801
72802
72803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72804   float jresult ;
72805   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72806   float arg2 ;
72807   float arg3 ;
72808   float arg4 ;
72809   Dali::Toolkit::ClampState *arg5 = 0 ;
72810   float result;
72811
72812   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72813   arg2 = (float)jarg2;
72814   arg3 = (float)jarg3;
72815   arg4 = (float)jarg4;
72816   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72817   if (!arg5) {
72818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72819     return 0;
72820   }
72821   {
72822     try {
72823       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72824     } catch (std::out_of_range& e) {
72825       {
72826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72827       };
72828     } catch (std::exception& e) {
72829       {
72830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72831       };
72832     } catch (Dali::DaliException e) {
72833       {
72834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72835       };
72836     } catch (...) {
72837       {
72838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72839       };
72840     }
72841   }
72842
72843   jresult = result;
72844   return jresult;
72845 }
72846
72847
72848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72849   float jresult ;
72850   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72851   float result;
72852
72853   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72854   {
72855     try {
72856       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72857     } catch (std::out_of_range& e) {
72858       {
72859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72860       };
72861     } catch (std::exception& e) {
72862       {
72863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72864       };
72865     } catch (Dali::DaliException e) {
72866       {
72867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72868       };
72869     } catch (...) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72872       };
72873     }
72874   }
72875
72876   jresult = result;
72877   return jresult;
72878 }
72879
72880
72881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72882   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72883
72884   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72885   {
72886     try {
72887       delete arg1;
72888     } catch (std::out_of_range& e) {
72889       {
72890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72891       };
72892     } catch (std::exception& e) {
72893       {
72894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72895       };
72896     } catch (Dali::DaliException e) {
72897       {
72898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72899       };
72900     } catch (...) {
72901       {
72902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72903       };
72904     }
72905   }
72906
72907 }
72908
72909
72910 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72911   float jresult ;
72912   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72913   float arg2 ;
72914   float arg3 ;
72915   float result;
72916
72917   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72918   arg2 = (float)jarg2;
72919   arg3 = (float)jarg3;
72920   {
72921     try {
72922       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72923     } catch (std::out_of_range& e) {
72924       {
72925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (std::exception& e) {
72928       {
72929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72930       };
72931     } catch (Dali::DaliException e) {
72932       {
72933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72934       };
72935     } catch (...) {
72936       {
72937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72938       };
72939     }
72940   }
72941
72942   jresult = result;
72943   return jresult;
72944 }
72945
72946
72947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72948   float jresult ;
72949   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72950   float arg2 ;
72951   float result;
72952
72953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72954   arg2 = (float)jarg2;
72955   {
72956     try {
72957       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72958     } catch (std::out_of_range& e) {
72959       {
72960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72961       };
72962     } catch (std::exception& e) {
72963       {
72964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (Dali::DaliException e) {
72967       {
72968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72969       };
72970     } catch (...) {
72971       {
72972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72973       };
72974     }
72975   }
72976
72977   jresult = result;
72978   return jresult;
72979 }
72980
72981
72982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72983   float jresult ;
72984   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72985   unsigned int arg2 ;
72986   unsigned int *arg3 = 0 ;
72987   bool arg4 ;
72988   float result;
72989
72990   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72991   arg2 = (unsigned int)jarg2;
72992   arg3 = (unsigned int *)jarg3;
72993   arg4 = jarg4 ? true : false;
72994   {
72995     try {
72996       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72997     } catch (std::out_of_range& e) {
72998       {
72999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73000       };
73001     } catch (std::exception& e) {
73002       {
73003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73004       };
73005     } catch (Dali::DaliException e) {
73006       {
73007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73008       };
73009     } catch (...) {
73010       {
73011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73012       };
73013     }
73014   }
73015
73016   jresult = result;
73017   return jresult;
73018 }
73019
73020
73021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73022   unsigned int jresult ;
73023   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73024   float arg2 ;
73025   bool arg3 ;
73026   unsigned int result;
73027
73028   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73029   arg2 = (float)jarg2;
73030   arg3 = jarg3 ? true : false;
73031   {
73032     try {
73033       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
73034     } catch (std::out_of_range& e) {
73035       {
73036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73037       };
73038     } catch (std::exception& e) {
73039       {
73040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73041       };
73042     } catch (Dali::DaliException e) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73045       };
73046     } catch (...) {
73047       {
73048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73049       };
73050     }
73051   }
73052
73053   jresult = result;
73054   return jresult;
73055 }
73056
73057
73058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
73059   unsigned int jresult ;
73060   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73061   unsigned int result;
73062
73063   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73064   {
73065     try {
73066       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73067     } catch (std::out_of_range& e) {
73068       {
73069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73070       };
73071     } catch (std::exception& e) {
73072       {
73073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73074       };
73075     } catch (Dali::DaliException e) {
73076       {
73077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73078       };
73079     } catch (...) {
73080       {
73081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73082       };
73083     }
73084   }
73085
73086   jresult = result;
73087   return jresult;
73088 }
73089
73090
73091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73092   int jresult ;
73093   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73094   Dali::Toolkit::Ruler::RulerType result;
73095
73096   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73097   {
73098     try {
73099       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73100     } catch (std::out_of_range& e) {
73101       {
73102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73103       };
73104     } catch (std::exception& e) {
73105       {
73106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73107       };
73108     } catch (Dali::DaliException e) {
73109       {
73110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73111       };
73112     } catch (...) {
73113       {
73114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73115       };
73116     }
73117   }
73118
73119   jresult = (int)result;
73120   return jresult;
73121 }
73122
73123
73124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73125   unsigned int jresult ;
73126   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73127   bool result;
73128
73129   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73130   {
73131     try {
73132       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73133     } catch (std::out_of_range& e) {
73134       {
73135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (std::exception& e) {
73138       {
73139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73140       };
73141     } catch (Dali::DaliException e) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73144       };
73145     } catch (...) {
73146       {
73147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73148       };
73149     }
73150   }
73151
73152   jresult = result;
73153   return jresult;
73154 }
73155
73156
73157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73158   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73159
73160   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73161   {
73162     try {
73163       (arg1)->Enable();
73164     } catch (std::out_of_range& e) {
73165       {
73166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73167       };
73168     } catch (std::exception& e) {
73169       {
73170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73171       };
73172     } catch (Dali::DaliException e) {
73173       {
73174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73175       };
73176     } catch (...) {
73177       {
73178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73179       };
73180     }
73181   }
73182
73183 }
73184
73185
73186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73187   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73188
73189   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73190   {
73191     try {
73192       (arg1)->Disable();
73193     } catch (std::out_of_range& e) {
73194       {
73195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73196       };
73197     } catch (std::exception& e) {
73198       {
73199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73200       };
73201     } catch (Dali::DaliException e) {
73202       {
73203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73208       };
73209     }
73210   }
73211
73212 }
73213
73214
73215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73216   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73217   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73218   Dali::Toolkit::RulerDomain *argp2 ;
73219
73220   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73221   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73222   if (!argp2) {
73223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73224     return ;
73225   }
73226   arg2 = *argp2;
73227   {
73228     try {
73229       (arg1)->SetDomain(arg2);
73230     } catch (std::out_of_range& e) {
73231       {
73232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73233       };
73234     } catch (std::exception& e) {
73235       {
73236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73237       };
73238     } catch (Dali::DaliException e) {
73239       {
73240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73241       };
73242     } catch (...) {
73243       {
73244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73245       };
73246     }
73247   }
73248
73249 }
73250
73251
73252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73253   void * jresult ;
73254   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73255   Dali::Toolkit::RulerDomain *result = 0 ;
73256
73257   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73258   {
73259     try {
73260       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73261     } catch (std::out_of_range& e) {
73262       {
73263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73264       };
73265     } catch (std::exception& e) {
73266       {
73267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73268       };
73269     } catch (Dali::DaliException e) {
73270       {
73271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73272       };
73273     } catch (...) {
73274       {
73275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73276       };
73277     }
73278   }
73279
73280   jresult = (void *)result;
73281   return jresult;
73282 }
73283
73284
73285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73286   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73287
73288   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73289   {
73290     try {
73291       (arg1)->DisableDomain();
73292     } catch (std::out_of_range& e) {
73293       {
73294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73295       };
73296     } catch (std::exception& e) {
73297       {
73298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73299       };
73300     } catch (Dali::DaliException e) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73303       };
73304     } catch (...) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73307       };
73308     }
73309   }
73310
73311 }
73312
73313
73314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73315   float jresult ;
73316   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73317   float arg2 ;
73318   float arg3 ;
73319   float arg4 ;
73320   float result;
73321
73322   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73323   arg2 = (float)jarg2;
73324   arg3 = (float)jarg3;
73325   arg4 = (float)jarg4;
73326   {
73327     try {
73328       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73329     } catch (std::out_of_range& e) {
73330       {
73331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73332       };
73333     } catch (std::exception& e) {
73334       {
73335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73336       };
73337     } catch (Dali::DaliException e) {
73338       {
73339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73340       };
73341     } catch (...) {
73342       {
73343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73344       };
73345     }
73346   }
73347
73348   jresult = result;
73349   return jresult;
73350 }
73351
73352
73353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73354   float jresult ;
73355   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73356   float arg2 ;
73357   float arg3 ;
73358   float result;
73359
73360   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73361   arg2 = (float)jarg2;
73362   arg3 = (float)jarg3;
73363   {
73364     try {
73365       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73366     } catch (std::out_of_range& e) {
73367       {
73368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73369       };
73370     } catch (std::exception& e) {
73371       {
73372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73373       };
73374     } catch (Dali::DaliException e) {
73375       {
73376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73377       };
73378     } catch (...) {
73379       {
73380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73381       };
73382     }
73383   }
73384
73385   jresult = result;
73386   return jresult;
73387 }
73388
73389
73390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73391   float jresult ;
73392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73393   float arg2 ;
73394   float result;
73395
73396   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73397   arg2 = (float)jarg2;
73398   {
73399     try {
73400       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73401     } catch (std::out_of_range& e) {
73402       {
73403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73404       };
73405     } catch (std::exception& e) {
73406       {
73407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73408       };
73409     } catch (Dali::DaliException e) {
73410       {
73411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73412       };
73413     } catch (...) {
73414       {
73415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73416       };
73417     }
73418   }
73419
73420   jresult = result;
73421   return jresult;
73422 }
73423
73424
73425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73426   float jresult ;
73427   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73428   float arg2 ;
73429   float arg3 ;
73430   float arg4 ;
73431   Dali::Toolkit::ClampState *arg5 = 0 ;
73432   float result;
73433
73434   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73435   arg2 = (float)jarg2;
73436   arg3 = (float)jarg3;
73437   arg4 = (float)jarg4;
73438   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73439   if (!arg5) {
73440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73441     return 0;
73442   }
73443   {
73444     try {
73445       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73446     } catch (std::out_of_range& e) {
73447       {
73448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73449       };
73450     } catch (std::exception& e) {
73451       {
73452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73453       };
73454     } catch (Dali::DaliException e) {
73455       {
73456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73457       };
73458     } catch (...) {
73459       {
73460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73461       };
73462     }
73463   }
73464
73465   jresult = result;
73466   return jresult;
73467 }
73468
73469
73470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73471   float jresult ;
73472   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73473   float arg2 ;
73474   float arg3 ;
73475   float arg4 ;
73476   float arg5 ;
73477   float result;
73478
73479   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73480   arg2 = (float)jarg2;
73481   arg3 = (float)jarg3;
73482   arg4 = (float)jarg4;
73483   arg5 = (float)jarg5;
73484   {
73485     try {
73486       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73487     } catch (std::out_of_range& e) {
73488       {
73489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (std::exception& e) {
73492       {
73493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73494       };
73495     } catch (Dali::DaliException e) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73498       };
73499     } catch (...) {
73500       {
73501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73502       };
73503     }
73504   }
73505
73506   jresult = result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73512   float jresult ;
73513   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73514   float arg2 ;
73515   float arg3 ;
73516   float arg4 ;
73517   float result;
73518
73519   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73520   arg2 = (float)jarg2;
73521   arg3 = (float)jarg3;
73522   arg4 = (float)jarg4;
73523   {
73524     try {
73525       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73526     } catch (std::out_of_range& e) {
73527       {
73528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73529       };
73530     } catch (std::exception& e) {
73531       {
73532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73533       };
73534     } catch (Dali::DaliException e) {
73535       {
73536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73537       };
73538     } catch (...) {
73539       {
73540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73541       };
73542     }
73543   }
73544
73545   jresult = result;
73546   return jresult;
73547 }
73548
73549
73550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73551   float jresult ;
73552   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73553   float arg2 ;
73554   float arg3 ;
73555   float result;
73556
73557   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73558   arg2 = (float)jarg2;
73559   arg3 = (float)jarg3;
73560   {
73561     try {
73562       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73563     } catch (std::out_of_range& e) {
73564       {
73565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73566       };
73567     } catch (std::exception& e) {
73568       {
73569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73570       };
73571     } catch (Dali::DaliException e) {
73572       {
73573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73574       };
73575     } catch (...) {
73576       {
73577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73578       };
73579     }
73580   }
73581
73582   jresult = result;
73583   return jresult;
73584 }
73585
73586
73587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73588   float jresult ;
73589   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73590   float arg2 ;
73591   float result;
73592
73593   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73594   arg2 = (float)jarg2;
73595   {
73596     try {
73597       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73598     } catch (std::out_of_range& e) {
73599       {
73600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73601       };
73602     } catch (std::exception& e) {
73603       {
73604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73605       };
73606     } catch (Dali::DaliException e) {
73607       {
73608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73609       };
73610     } catch (...) {
73611       {
73612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73613       };
73614     }
73615   }
73616
73617   jresult = result;
73618   return jresult;
73619 }
73620
73621
73622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73623   float jresult ;
73624   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73625   float arg2 ;
73626   float arg3 ;
73627   float arg4 ;
73628   float arg5 ;
73629   Dali::Toolkit::ClampState *arg6 = 0 ;
73630   float result;
73631
73632   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73633   arg2 = (float)jarg2;
73634   arg3 = (float)jarg3;
73635   arg4 = (float)jarg4;
73636   arg5 = (float)jarg5;
73637   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73638   if (!arg6) {
73639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73640     return 0;
73641   }
73642   {
73643     try {
73644       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73645     } catch (std::out_of_range& e) {
73646       {
73647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73648       };
73649     } catch (std::exception& e) {
73650       {
73651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73652       };
73653     } catch (Dali::DaliException e) {
73654       {
73655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73656       };
73657     } catch (...) {
73658       {
73659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73660       };
73661     }
73662   }
73663
73664   jresult = result;
73665   return jresult;
73666 }
73667
73668
73669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73670   void * jresult ;
73671   Dali::Toolkit::DefaultRuler *result = 0 ;
73672
73673   {
73674     try {
73675       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73676     } catch (std::out_of_range& e) {
73677       {
73678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73679       };
73680     } catch (std::exception& e) {
73681       {
73682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73683       };
73684     } catch (Dali::DaliException e) {
73685       {
73686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73687       };
73688     } catch (...) {
73689       {
73690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73691       };
73692     }
73693   }
73694
73695   jresult = (void *)result;
73696   return jresult;
73697 }
73698
73699
73700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73701   float jresult ;
73702   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73703   float arg2 ;
73704   float arg3 ;
73705   float result;
73706
73707   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73708   arg2 = (float)jarg2;
73709   arg3 = (float)jarg3;
73710   {
73711     try {
73712       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73713     } catch (std::out_of_range& e) {
73714       {
73715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73716       };
73717     } catch (std::exception& e) {
73718       {
73719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73720       };
73721     } catch (Dali::DaliException e) {
73722       {
73723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73724       };
73725     } catch (...) {
73726       {
73727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73728       };
73729     }
73730   }
73731
73732   jresult = result;
73733   return jresult;
73734 }
73735
73736
73737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73738   float jresult ;
73739   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73740   unsigned int arg2 ;
73741   unsigned int *arg3 = 0 ;
73742   bool arg4 ;
73743   float result;
73744
73745   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73746   arg2 = (unsigned int)jarg2;
73747   arg3 = (unsigned int *)jarg3;
73748   arg4 = jarg4 ? true : false;
73749   {
73750     try {
73751       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73752     } catch (std::out_of_range& e) {
73753       {
73754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73755       };
73756     } catch (std::exception& e) {
73757       {
73758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (Dali::DaliException e) {
73761       {
73762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73763       };
73764     } catch (...) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73767       };
73768     }
73769   }
73770
73771   jresult = result;
73772   return jresult;
73773 }
73774
73775
73776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73777   unsigned int jresult ;
73778   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73779   float arg2 ;
73780   bool arg3 ;
73781   unsigned int result;
73782
73783   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73784   arg2 = (float)jarg2;
73785   arg3 = jarg3 ? true : false;
73786   {
73787     try {
73788       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73789     } catch (std::out_of_range& e) {
73790       {
73791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73792       };
73793     } catch (std::exception& e) {
73794       {
73795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73796       };
73797     } catch (Dali::DaliException e) {
73798       {
73799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73800       };
73801     } catch (...) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73804       };
73805     }
73806   }
73807
73808   jresult = result;
73809   return jresult;
73810 }
73811
73812
73813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73814   unsigned int jresult ;
73815   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73816   unsigned int result;
73817
73818   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73819   {
73820     try {
73821       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73822     } catch (std::out_of_range& e) {
73823       {
73824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73825       };
73826     } catch (std::exception& e) {
73827       {
73828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73829       };
73830     } catch (Dali::DaliException e) {
73831       {
73832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73833       };
73834     } catch (...) {
73835       {
73836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73837       };
73838     }
73839   }
73840
73841   jresult = result;
73842   return jresult;
73843 }
73844
73845
73846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73847   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73848
73849   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73850   {
73851     try {
73852       delete arg1;
73853     } catch (std::out_of_range& e) {
73854       {
73855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73856       };
73857     } catch (std::exception& e) {
73858       {
73859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73860       };
73861     } catch (Dali::DaliException e) {
73862       {
73863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73864       };
73865     } catch (...) {
73866       {
73867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73868       };
73869     }
73870   }
73871
73872 }
73873
73874
73875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73876   void * jresult ;
73877   float arg1 ;
73878   Dali::Toolkit::FixedRuler *result = 0 ;
73879
73880   arg1 = (float)jarg1;
73881   {
73882     try {
73883       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (Dali::DaliException e) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73899       };
73900     }
73901   }
73902
73903   jresult = (void *)result;
73904   return jresult;
73905 }
73906
73907
73908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73909   void * jresult ;
73910   Dali::Toolkit::FixedRuler *result = 0 ;
73911
73912   {
73913     try {
73914       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73915     } catch (std::out_of_range& e) {
73916       {
73917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73918       };
73919     } catch (std::exception& e) {
73920       {
73921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73922       };
73923     } catch (Dali::DaliException e) {
73924       {
73925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73926       };
73927     } catch (...) {
73928       {
73929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73930       };
73931     }
73932   }
73933
73934   jresult = (void *)result;
73935   return jresult;
73936 }
73937
73938
73939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73940   float jresult ;
73941   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73942   float arg2 ;
73943   float arg3 ;
73944   float result;
73945
73946   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73947   arg2 = (float)jarg2;
73948   arg3 = (float)jarg3;
73949   {
73950     try {
73951       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73952     } catch (std::out_of_range& e) {
73953       {
73954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73955       };
73956     } catch (std::exception& e) {
73957       {
73958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73959       };
73960     } catch (Dali::DaliException e) {
73961       {
73962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73963       };
73964     } catch (...) {
73965       {
73966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73967       };
73968     }
73969   }
73970
73971   jresult = result;
73972   return jresult;
73973 }
73974
73975
73976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73977   float jresult ;
73978   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73979   unsigned int arg2 ;
73980   unsigned int *arg3 = 0 ;
73981   bool arg4 ;
73982   float result;
73983
73984   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73985   arg2 = (unsigned int)jarg2;
73986   arg3 = (unsigned int *)jarg3;
73987   arg4 = jarg4 ? true : false;
73988   {
73989     try {
73990       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73991     } catch (std::out_of_range& e) {
73992       {
73993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73994       };
73995     } catch (std::exception& e) {
73996       {
73997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73998       };
73999     } catch (Dali::DaliException e) {
74000       {
74001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74002       };
74003     } catch (...) {
74004       {
74005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74006       };
74007     }
74008   }
74009
74010   jresult = result;
74011   return jresult;
74012 }
74013
74014
74015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74016   unsigned int jresult ;
74017   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74018   float arg2 ;
74019   bool arg3 ;
74020   unsigned int result;
74021
74022   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74023   arg2 = (float)jarg2;
74024   arg3 = jarg3 ? true : false;
74025   {
74026     try {
74027       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74028     } catch (std::out_of_range& e) {
74029       {
74030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74031       };
74032     } catch (std::exception& e) {
74033       {
74034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74035       };
74036     } catch (Dali::DaliException e) {
74037       {
74038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74039       };
74040     } catch (...) {
74041       {
74042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74043       };
74044     }
74045   }
74046
74047   jresult = result;
74048   return jresult;
74049 }
74050
74051
74052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
74053   unsigned int jresult ;
74054   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74055   unsigned int result;
74056
74057   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74058   {
74059     try {
74060       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
74061     } catch (std::out_of_range& e) {
74062       {
74063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74064       };
74065     } catch (std::exception& e) {
74066       {
74067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74068       };
74069     } catch (Dali::DaliException e) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74072       };
74073     } catch (...) {
74074       {
74075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74076       };
74077     }
74078   }
74079
74080   jresult = result;
74081   return jresult;
74082 }
74083
74084
74085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74086   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74087
74088   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74089   {
74090     try {
74091       delete arg1;
74092     } catch (std::out_of_range& e) {
74093       {
74094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74095       };
74096     } catch (std::exception& e) {
74097       {
74098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74099       };
74100     } catch (Dali::DaliException e) {
74101       {
74102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74103       };
74104     } catch (...) {
74105       {
74106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74107       };
74108     }
74109   }
74110
74111 }
74112
74113
74114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74115   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74116   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74117
74118   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74119   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74120   if (arg1) (arg1)->scale = *arg2;
74121 }
74122
74123
74124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74125   void * jresult ;
74126   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74127   Dali::Toolkit::ClampState2D *result = 0 ;
74128
74129   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74130   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74131   jresult = (void *)result;
74132   return jresult;
74133 }
74134
74135
74136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74137   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74138   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74139
74140   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74141   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74142   if (arg1) (arg1)->position = *arg2;
74143 }
74144
74145
74146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74147   void * jresult ;
74148   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74149   Dali::Toolkit::ClampState2D *result = 0 ;
74150
74151   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74152   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74153   jresult = (void *)result;
74154   return jresult;
74155 }
74156
74157
74158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74159   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74160   Dali::Toolkit::ClampState arg2 ;
74161
74162   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74163   arg2 = (Dali::Toolkit::ClampState)jarg2;
74164   if (arg1) (arg1)->rotation = arg2;
74165 }
74166
74167
74168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74169   int jresult ;
74170   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74171   Dali::Toolkit::ClampState result;
74172
74173   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74174   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74175   jresult = (int)result;
74176   return jresult;
74177 }
74178
74179
74180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74181   void * jresult ;
74182   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74183
74184   {
74185     try {
74186       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74187     } catch (std::out_of_range& e) {
74188       {
74189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74190       };
74191     } catch (std::exception& e) {
74192       {
74193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74194       };
74195     } catch (Dali::DaliException e) {
74196       {
74197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74198       };
74199     } catch (...) {
74200       {
74201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74202       };
74203     }
74204   }
74205
74206   jresult = (void *)result;
74207   return jresult;
74208 }
74209
74210
74211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74212   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74213
74214   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74215   {
74216     try {
74217       delete arg1;
74218     } catch (std::out_of_range& e) {
74219       {
74220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74221       };
74222     } catch (std::exception& e) {
74223       {
74224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74225       };
74226     } catch (Dali::DaliException e) {
74227       {
74228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74229       };
74230     } catch (...) {
74231       {
74232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74233       };
74234     }
74235   }
74236
74237 }
74238
74239
74240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74241   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74242   Dali::Toolkit::SnapType arg2 ;
74243
74244   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74245   arg2 = (Dali::Toolkit::SnapType)jarg2;
74246   if (arg1) (arg1)->type = arg2;
74247 }
74248
74249
74250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74251   int jresult ;
74252   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74253   Dali::Toolkit::SnapType result;
74254
74255   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74256   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74257   jresult = (int)result;
74258   return jresult;
74259 }
74260
74261
74262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74263   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74264   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74265
74266   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74267   arg2 = (Dali::Vector2 *)jarg2;
74268   if (arg1) (arg1)->position = *arg2;
74269 }
74270
74271
74272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74273   void * jresult ;
74274   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74275   Dali::Vector2 *result = 0 ;
74276
74277   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74278   result = (Dali::Vector2 *)& ((arg1)->position);
74279   jresult = (void *)result;
74280   return jresult;
74281 }
74282
74283
74284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74285   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74286   float arg2 ;
74287
74288   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74289   arg2 = (float)jarg2;
74290   if (arg1) (arg1)->duration = arg2;
74291 }
74292
74293
74294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74295   float jresult ;
74296   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74297   float result;
74298
74299   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74300   result = (float) ((arg1)->duration);
74301   jresult = result;
74302   return jresult;
74303 }
74304
74305
74306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74307   void * jresult ;
74308   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74309
74310   {
74311     try {
74312       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74313     } catch (std::out_of_range& e) {
74314       {
74315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74316       };
74317     } catch (std::exception& e) {
74318       {
74319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74320       };
74321     } catch (Dali::DaliException e) {
74322       {
74323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74324       };
74325     } catch (...) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74328       };
74329     }
74330   }
74331
74332   jresult = (void *)result;
74333   return jresult;
74334 }
74335
74336
74337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74338   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74339
74340   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74341   {
74342     try {
74343       delete arg1;
74344     } catch (std::out_of_range& e) {
74345       {
74346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74347       };
74348     } catch (std::exception& e) {
74349       {
74350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74351       };
74352     } catch (Dali::DaliException e) {
74353       {
74354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74355       };
74356     } catch (...) {
74357       {
74358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74359       };
74360     }
74361   }
74362
74363 }
74364
74365
74366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74367   int jresult ;
74368   int result;
74369
74370   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74371   jresult = (int)result;
74372   return jresult;
74373 }
74374
74375
74376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74377   int jresult ;
74378   int result;
74379
74380   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74381   jresult = (int)result;
74382   return jresult;
74383 }
74384
74385
74386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74387   int jresult ;
74388   int result;
74389
74390   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74391   jresult = (int)result;
74392   return jresult;
74393 }
74394
74395
74396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74397   int jresult ;
74398   int result;
74399
74400   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74401   jresult = (int)result;
74402   return jresult;
74403 }
74404
74405
74406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74407   int jresult ;
74408   int result;
74409
74410   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74411   jresult = (int)result;
74412   return jresult;
74413 }
74414
74415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74416   int jresult ;
74417   int result;
74418
74419   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74420   jresult = (int)result;
74421   return jresult;
74422 }
74423
74424
74425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74426   int jresult ;
74427   int result;
74428
74429   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74430   jresult = (int)result;
74431   return jresult;
74432 }
74433
74434
74435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74436   int jresult ;
74437   int result;
74438
74439   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74440   jresult = (int)result;
74441   return jresult;
74442 }
74443
74444
74445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74446   int jresult ;
74447   int result;
74448
74449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74450   jresult = (int)result;
74451   return jresult;
74452 }
74453
74454
74455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74456   int jresult ;
74457   int result;
74458
74459   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74460   jresult = (int)result;
74461   return jresult;
74462 }
74463
74464
74465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74466   int jresult ;
74467   int result;
74468
74469   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74470   jresult = (int)result;
74471   return jresult;
74472 }
74473
74474
74475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74476   int jresult ;
74477   int result;
74478
74479   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74480   jresult = (int)result;
74481   return jresult;
74482 }
74483
74484
74485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74486   int jresult ;
74487   int result;
74488
74489   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74490   jresult = (int)result;
74491   return jresult;
74492 }
74493
74494
74495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74496   int jresult ;
74497   int result;
74498
74499   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74500   jresult = (int)result;
74501   return jresult;
74502 }
74503
74504
74505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74506   int jresult ;
74507   int result;
74508
74509   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74510   jresult = (int)result;
74511   return jresult;
74512 }
74513
74514
74515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74516   int jresult ;
74517   int result;
74518
74519   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74520   jresult = (int)result;
74521   return jresult;
74522 }
74523
74524
74525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74526   int jresult ;
74527   int result;
74528
74529   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74530   jresult = (int)result;
74531   return jresult;
74532 }
74533
74534
74535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74536   int jresult ;
74537   int result;
74538
74539   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74540   jresult = (int)result;
74541   return jresult;
74542 }
74543
74544
74545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74546   int jresult ;
74547   int result;
74548
74549   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74550   jresult = (int)result;
74551   return jresult;
74552 }
74553
74554
74555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74556   int jresult ;
74557   int result;
74558
74559   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74560   jresult = (int)result;
74561   return jresult;
74562 }
74563
74564
74565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74566   int jresult ;
74567   int result;
74568
74569   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74570   jresult = (int)result;
74571   return jresult;
74572 }
74573
74574
74575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74576   int jresult ;
74577   int result;
74578
74579   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74580   jresult = (int)result;
74581   return jresult;
74582 }
74583
74584
74585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74586   int jresult ;
74587   int result;
74588
74589   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74590   jresult = (int)result;
74591   return jresult;
74592 }
74593
74594
74595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74596   int jresult ;
74597   int result;
74598
74599   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74600   jresult = (int)result;
74601   return jresult;
74602 }
74603
74604
74605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74606   int jresult ;
74607   int result;
74608
74609   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74610   jresult = (int)result;
74611   return jresult;
74612 }
74613
74614
74615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74616   int jresult ;
74617   int result;
74618
74619   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74620   jresult = (int)result;
74621   return jresult;
74622 }
74623
74624
74625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74626   void * jresult ;
74627   Dali::Toolkit::ScrollView::Property *result = 0 ;
74628
74629   {
74630     try {
74631       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74632     } catch (std::out_of_range& e) {
74633       {
74634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74635       };
74636     } catch (std::exception& e) {
74637       {
74638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74639       };
74640     } catch (Dali::DaliException e) {
74641       {
74642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74643       };
74644     } catch (...) {
74645       {
74646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74647       };
74648     }
74649   }
74650
74651   jresult = (void *)result;
74652   return jresult;
74653 }
74654
74655
74656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74657   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74658
74659   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74660   {
74661     try {
74662       delete arg1;
74663     } catch (std::out_of_range& e) {
74664       {
74665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74666       };
74667     } catch (std::exception& e) {
74668       {
74669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74670       };
74671     } catch (Dali::DaliException e) {
74672       {
74673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74674       };
74675     } catch (...) {
74676       {
74677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74678       };
74679     }
74680   }
74681
74682 }
74683
74684
74685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74686   void * jresult ;
74687   Dali::Toolkit::ScrollView *result = 0 ;
74688
74689   {
74690     try {
74691       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74692     } catch (std::out_of_range& e) {
74693       {
74694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74695       };
74696     } catch (std::exception& e) {
74697       {
74698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74699       };
74700     } catch (Dali::DaliException e) {
74701       {
74702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74703       };
74704     } catch (...) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74707       };
74708     }
74709   }
74710
74711   jresult = (void *)result;
74712   return jresult;
74713 }
74714
74715
74716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74717   void * jresult ;
74718   Dali::Toolkit::ScrollView *arg1 = 0 ;
74719   Dali::Toolkit::ScrollView *result = 0 ;
74720
74721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74722   if (!arg1) {
74723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74724     return 0;
74725   }
74726   {
74727     try {
74728       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74729     } catch (std::out_of_range& e) {
74730       {
74731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74732       };
74733     } catch (std::exception& e) {
74734       {
74735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74736       };
74737     } catch (Dali::DaliException e) {
74738       {
74739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74740       };
74741     } catch (...) {
74742       {
74743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74744       };
74745     }
74746   }
74747
74748   jresult = (void *)result;
74749   return jresult;
74750 }
74751
74752
74753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74754   void * jresult ;
74755   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74756   Dali::Toolkit::ScrollView *arg2 = 0 ;
74757   Dali::Toolkit::ScrollView *result = 0 ;
74758
74759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74760   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74761   if (!arg2) {
74762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74763     return 0;
74764   }
74765   {
74766     try {
74767       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74768     } catch (std::out_of_range& e) {
74769       {
74770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74771       };
74772     } catch (std::exception& e) {
74773       {
74774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74775       };
74776     } catch (Dali::DaliException e) {
74777       {
74778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74779       };
74780     } catch (...) {
74781       {
74782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74783       };
74784     }
74785   }
74786
74787   jresult = (void *)result;
74788   return jresult;
74789 }
74790
74791
74792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74794
74795   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74796   {
74797     try {
74798       delete arg1;
74799     } catch (std::out_of_range& e) {
74800       {
74801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74802       };
74803     } catch (std::exception& e) {
74804       {
74805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74806       };
74807     } catch (Dali::DaliException e) {
74808       {
74809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74810       };
74811     } catch (...) {
74812       {
74813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74814       };
74815     }
74816   }
74817
74818 }
74819
74820
74821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74822   void * jresult ;
74823   Dali::Toolkit::ScrollView result;
74824
74825   {
74826     try {
74827       result = Dali::Toolkit::ScrollView::New();
74828     } catch (std::out_of_range& e) {
74829       {
74830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74831       };
74832     } catch (std::exception& e) {
74833       {
74834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74835       };
74836     } catch (Dali::DaliException e) {
74837       {
74838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74839       };
74840     } catch (...) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74843       };
74844     }
74845   }
74846
74847   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74848   return jresult;
74849 }
74850
74851
74852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74853   void * jresult ;
74854   Dali::BaseHandle arg1 ;
74855   Dali::BaseHandle *argp1 ;
74856   Dali::Toolkit::ScrollView result;
74857
74858   argp1 = (Dali::BaseHandle *)jarg1;
74859   if (!argp1) {
74860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74861     return 0;
74862   }
74863   arg1 = *argp1;
74864   {
74865     try {
74866       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (Dali::DaliException e) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74878       };
74879     } catch (...) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74882       };
74883     }
74884   }
74885
74886   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74887   return jresult;
74888 }
74889
74890
74891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74892   void * jresult ;
74893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74894   Dali::AlphaFunction result;
74895
74896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74897   {
74898     try {
74899       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74900     } catch (std::out_of_range& e) {
74901       {
74902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74903       };
74904     } catch (std::exception& e) {
74905       {
74906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74907       };
74908     } catch (Dali::DaliException e) {
74909       {
74910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74911       };
74912     } catch (...) {
74913       {
74914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74915       };
74916     }
74917   }
74918
74919   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74920   return jresult;
74921 }
74922
74923
74924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74925   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74926   Dali::AlphaFunction arg2 ;
74927   Dali::AlphaFunction *argp2 ;
74928
74929   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74930   argp2 = (Dali::AlphaFunction *)jarg2;
74931   if (!argp2) {
74932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74933     return ;
74934   }
74935   arg2 = *argp2;
74936   {
74937     try {
74938       (arg1)->SetScrollSnapAlphaFunction(arg2);
74939     } catch (std::out_of_range& e) {
74940       {
74941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74942       };
74943     } catch (std::exception& e) {
74944       {
74945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74946       };
74947     } catch (Dali::DaliException e) {
74948       {
74949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74950       };
74951     } catch (...) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74954       };
74955     }
74956   }
74957
74958 }
74959
74960
74961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74962   void * jresult ;
74963   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74964   Dali::AlphaFunction result;
74965
74966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74967   {
74968     try {
74969       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74970     } catch (std::out_of_range& e) {
74971       {
74972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74973       };
74974     } catch (std::exception& e) {
74975       {
74976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74977       };
74978     } catch (Dali::DaliException e) {
74979       {
74980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74981       };
74982     } catch (...) {
74983       {
74984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74985       };
74986     }
74987   }
74988
74989   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74990   return jresult;
74991 }
74992
74993
74994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74996   Dali::AlphaFunction arg2 ;
74997   Dali::AlphaFunction *argp2 ;
74998
74999   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75000   argp2 = (Dali::AlphaFunction *)jarg2;
75001   if (!argp2) {
75002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75003     return ;
75004   }
75005   arg2 = *argp2;
75006   {
75007     try {
75008       (arg1)->SetScrollFlickAlphaFunction(arg2);
75009     } catch (std::out_of_range& e) {
75010       {
75011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75012       };
75013     } catch (std::exception& e) {
75014       {
75015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75016       };
75017     } catch (Dali::DaliException e) {
75018       {
75019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75020       };
75021     } catch (...) {
75022       {
75023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75024       };
75025     }
75026   }
75027
75028 }
75029
75030
75031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
75032   float jresult ;
75033   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75034   float result;
75035
75036   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75037   {
75038     try {
75039       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
75040     } catch (std::out_of_range& e) {
75041       {
75042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (std::exception& e) {
75045       {
75046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75047       };
75048     } catch (Dali::DaliException e) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75051       };
75052     } catch (...) {
75053       {
75054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75055       };
75056     }
75057   }
75058
75059   jresult = result;
75060   return jresult;
75061 }
75062
75063
75064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
75065   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75066   float arg2 ;
75067
75068   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75069   arg2 = (float)jarg2;
75070   {
75071     try {
75072       (arg1)->SetScrollSnapDuration(arg2);
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (Dali::DaliException e) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75084       };
75085     } catch (...) {
75086       {
75087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75088       };
75089     }
75090   }
75091
75092 }
75093
75094
75095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75096   float jresult ;
75097   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75098   float result;
75099
75100   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75101   {
75102     try {
75103       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75104     } catch (std::out_of_range& e) {
75105       {
75106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75107       };
75108     } catch (std::exception& e) {
75109       {
75110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (Dali::DaliException e) {
75113       {
75114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75115       };
75116     } catch (...) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75119       };
75120     }
75121   }
75122
75123   jresult = result;
75124   return jresult;
75125 }
75126
75127
75128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75130   float arg2 ;
75131
75132   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75133   arg2 = (float)jarg2;
75134   {
75135     try {
75136       (arg1)->SetScrollFlickDuration(arg2);
75137     } catch (std::out_of_range& e) {
75138       {
75139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75140       };
75141     } catch (std::exception& e) {
75142       {
75143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75144       };
75145     } catch (Dali::DaliException e) {
75146       {
75147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75148       };
75149     } catch (...) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75152       };
75153     }
75154   }
75155
75156 }
75157
75158
75159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75160   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75161   Dali::Toolkit::RulerPtr arg2 ;
75162   Dali::Toolkit::RulerPtr *argp2 ;
75163
75164   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75165   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75166   if (!argp2) {
75167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75168     return ;
75169   }
75170   arg2 = *argp2;
75171   {
75172     try {
75173       (arg1)->SetRulerX(arg2);
75174     } catch (std::out_of_range& e) {
75175       {
75176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75177       };
75178     } catch (std::exception& e) {
75179       {
75180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75181       };
75182     } catch (Dali::DaliException e) {
75183       {
75184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75185       };
75186     } catch (...) {
75187       {
75188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75189       };
75190     }
75191   }
75192
75193 }
75194
75195
75196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75198   Dali::Toolkit::RulerPtr arg2 ;
75199   Dali::Toolkit::RulerPtr *argp2 ;
75200
75201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75202   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75203   if (!argp2) {
75204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75205     return ;
75206   }
75207   arg2 = *argp2;
75208   {
75209     try {
75210       (arg1)->SetRulerY(arg2);
75211     } catch (std::out_of_range& e) {
75212       {
75213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75214       };
75215     } catch (std::exception& e) {
75216       {
75217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75218       };
75219     } catch (Dali::DaliException e) {
75220       {
75221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75222       };
75223     } catch (...) {
75224       {
75225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75226       };
75227     }
75228   }
75229
75230 }
75231
75232
75233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75235   bool arg2 ;
75236
75237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75238   arg2 = jarg2 ? true : false;
75239   {
75240     try {
75241       (arg1)->SetScrollSensitive(arg2);
75242     } catch (std::out_of_range& e) {
75243       {
75244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75245       };
75246     } catch (std::exception& e) {
75247       {
75248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75249       };
75250     } catch (Dali::DaliException e) {
75251       {
75252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75253       };
75254     } catch (...) {
75255       {
75256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75257       };
75258     }
75259   }
75260
75261 }
75262
75263
75264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75266   float arg2 ;
75267   float arg3 ;
75268
75269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75270   arg2 = (float)jarg2;
75271   arg3 = (float)jarg3;
75272   {
75273     try {
75274       (arg1)->SetMaxOvershoot(arg2,arg3);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75282       };
75283     } catch (Dali::DaliException e) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75286       };
75287     } catch (...) {
75288       {
75289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75290       };
75291     }
75292   }
75293
75294 }
75295
75296
75297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75298   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75299   Dali::AlphaFunction arg2 ;
75300   Dali::AlphaFunction *argp2 ;
75301
75302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75303   argp2 = (Dali::AlphaFunction *)jarg2;
75304   if (!argp2) {
75305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75306     return ;
75307   }
75308   arg2 = *argp2;
75309   {
75310     try {
75311       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75312     } catch (std::out_of_range& e) {
75313       {
75314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75315       };
75316     } catch (std::exception& e) {
75317       {
75318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75319       };
75320     } catch (Dali::DaliException e) {
75321       {
75322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75323       };
75324     } catch (...) {
75325       {
75326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75327       };
75328     }
75329   }
75330
75331 }
75332
75333
75334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75336   float arg2 ;
75337
75338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75339   arg2 = (float)jarg2;
75340   {
75341     try {
75342       (arg1)->SetSnapOvershootDuration(arg2);
75343     } catch (std::out_of_range& e) {
75344       {
75345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75346       };
75347     } catch (std::exception& e) {
75348       {
75349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75350       };
75351     } catch (Dali::DaliException e) {
75352       {
75353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75354       };
75355     } catch (...) {
75356       {
75357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75358       };
75359     }
75360   }
75361
75362 }
75363
75364
75365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75366   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75367   bool arg2 ;
75368
75369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75370   arg2 = jarg2 ? true : false;
75371   {
75372     try {
75373       (arg1)->SetActorAutoSnap(arg2);
75374     } catch (std::out_of_range& e) {
75375       {
75376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75377       };
75378     } catch (std::exception& e) {
75379       {
75380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75381       };
75382     } catch (Dali::DaliException e) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75385       };
75386     } catch (...) {
75387       {
75388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75389       };
75390     }
75391   }
75392
75393 }
75394
75395
75396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75397   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75398   bool arg2 ;
75399
75400   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75401   arg2 = jarg2 ? true : false;
75402   {
75403     try {
75404       (arg1)->SetWrapMode(arg2);
75405     } catch (std::out_of_range& e) {
75406       {
75407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75408       };
75409     } catch (std::exception& e) {
75410       {
75411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75412       };
75413     } catch (Dali::DaliException e) {
75414       {
75415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75416       };
75417     } catch (...) {
75418       {
75419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75420       };
75421     }
75422   }
75423
75424 }
75425
75426
75427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75428   int jresult ;
75429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75430   int result;
75431
75432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75433   {
75434     try {
75435       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75436     } catch (std::out_of_range& e) {
75437       {
75438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75439       };
75440     } catch (std::exception& e) {
75441       {
75442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75443       };
75444     } catch (Dali::DaliException e) {
75445       {
75446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75447       };
75448     } catch (...) {
75449       {
75450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75451       };
75452     }
75453   }
75454
75455   jresult = result;
75456   return jresult;
75457 }
75458
75459
75460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75462   int arg2 ;
75463
75464   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75465   arg2 = (int)jarg2;
75466   {
75467     try {
75468       (arg1)->SetScrollUpdateDistance(arg2);
75469     } catch (std::out_of_range& e) {
75470       {
75471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75472       };
75473     } catch (std::exception& e) {
75474       {
75475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75476       };
75477     } catch (Dali::DaliException e) {
75478       {
75479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75480       };
75481     } catch (...) {
75482       {
75483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75484       };
75485     }
75486   }
75487
75488 }
75489
75490
75491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75492   unsigned int jresult ;
75493   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75494   bool result;
75495
75496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75497   {
75498     try {
75499       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75500     } catch (std::out_of_range& e) {
75501       {
75502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75503       };
75504     } catch (std::exception& e) {
75505       {
75506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75507       };
75508     } catch (Dali::DaliException e) {
75509       {
75510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75511       };
75512     } catch (...) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75515       };
75516     }
75517   }
75518
75519   jresult = result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75526   bool arg2 ;
75527
75528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75529   arg2 = jarg2 ? true : false;
75530   {
75531     try {
75532       (arg1)->SetAxisAutoLock(arg2);
75533     } catch (std::out_of_range& e) {
75534       {
75535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75536       };
75537     } catch (std::exception& e) {
75538       {
75539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75540       };
75541     } catch (Dali::DaliException e) {
75542       {
75543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75544       };
75545     } catch (...) {
75546       {
75547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75548       };
75549     }
75550   }
75551
75552 }
75553
75554
75555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75556   float jresult ;
75557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75558   float result;
75559
75560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75561   {
75562     try {
75563       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75564     } catch (std::out_of_range& e) {
75565       {
75566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75567       };
75568     } catch (std::exception& e) {
75569       {
75570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75571       };
75572     } catch (Dali::DaliException e) {
75573       {
75574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75575       };
75576     } catch (...) {
75577       {
75578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75579       };
75580     }
75581   }
75582
75583   jresult = result;
75584   return jresult;
75585 }
75586
75587
75588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75589   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75590   float arg2 ;
75591
75592   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75593   arg2 = (float)jarg2;
75594   {
75595     try {
75596       (arg1)->SetAxisAutoLockGradient(arg2);
75597     } catch (std::out_of_range& e) {
75598       {
75599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75600       };
75601     } catch (std::exception& e) {
75602       {
75603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75604       };
75605     } catch (Dali::DaliException e) {
75606       {
75607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75608       };
75609     } catch (...) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75612       };
75613     }
75614   }
75615
75616 }
75617
75618
75619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75620   float jresult ;
75621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75622   float result;
75623
75624   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75625   {
75626     try {
75627       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75628     } catch (std::out_of_range& e) {
75629       {
75630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75631       };
75632     } catch (std::exception& e) {
75633       {
75634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75635       };
75636     } catch (Dali::DaliException e) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75639       };
75640     } catch (...) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75643       };
75644     }
75645   }
75646
75647   jresult = result;
75648   return jresult;
75649 }
75650
75651
75652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75654   float arg2 ;
75655
75656   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75657   arg2 = (float)jarg2;
75658   {
75659     try {
75660       (arg1)->SetFrictionCoefficient(arg2);
75661     } catch (std::out_of_range& e) {
75662       {
75663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75664       };
75665     } catch (std::exception& e) {
75666       {
75667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75668       };
75669     } catch (Dali::DaliException e) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75676       };
75677     }
75678   }
75679
75680 }
75681
75682
75683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75684   float jresult ;
75685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75686   float result;
75687
75688   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75689   {
75690     try {
75691       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75692     } catch (std::out_of_range& e) {
75693       {
75694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75695       };
75696     } catch (std::exception& e) {
75697       {
75698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75699       };
75700     } catch (Dali::DaliException e) {
75701       {
75702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75703       };
75704     } catch (...) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75707       };
75708     }
75709   }
75710
75711   jresult = result;
75712   return jresult;
75713 }
75714
75715
75716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75717   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75718   float arg2 ;
75719
75720   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75721   arg2 = (float)jarg2;
75722   {
75723     try {
75724       (arg1)->SetFlickSpeedCoefficient(arg2);
75725     } catch (std::out_of_range& e) {
75726       {
75727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75728       };
75729     } catch (std::exception& e) {
75730       {
75731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75732       };
75733     } catch (Dali::DaliException e) {
75734       {
75735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75736       };
75737     } catch (...) {
75738       {
75739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75740       };
75741     }
75742   }
75743
75744 }
75745
75746
75747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75748   void * jresult ;
75749   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75750   Dali::Vector2 result;
75751
75752   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75753   {
75754     try {
75755       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75756     } catch (std::out_of_range& e) {
75757       {
75758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75759       };
75760     } catch (std::exception& e) {
75761       {
75762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75763       };
75764     } catch (Dali::DaliException e) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75767       };
75768     } catch (...) {
75769       {
75770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75771       };
75772     }
75773   }
75774
75775   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75776   return jresult;
75777 }
75778
75779
75780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75781   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75782   Dali::Vector2 *arg2 = 0 ;
75783
75784   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75785   arg2 = (Dali::Vector2 *)jarg2;
75786   if (!arg2) {
75787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75788     return ;
75789   }
75790   {
75791     try {
75792       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75793     } catch (std::out_of_range& e) {
75794       {
75795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75796       };
75797     } catch (std::exception& e) {
75798       {
75799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75800       };
75801     } catch (Dali::DaliException e) {
75802       {
75803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75804       };
75805     } catch (...) {
75806       {
75807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75808       };
75809     }
75810   }
75811
75812 }
75813
75814
75815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75816   float jresult ;
75817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75818   float result;
75819
75820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75821   {
75822     try {
75823       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75831       };
75832     } catch (Dali::DaliException e) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75835       };
75836     } catch (...) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75839       };
75840     }
75841   }
75842
75843   jresult = result;
75844   return jresult;
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75849   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75850   float arg2 ;
75851
75852   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75853   arg2 = (float)jarg2;
75854   {
75855     try {
75856       (arg1)->SetMinimumSpeedForFlick(arg2);
75857     } catch (std::out_of_range& e) {
75858       {
75859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75860       };
75861     } catch (std::exception& e) {
75862       {
75863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (Dali::DaliException e) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75868       };
75869     } catch (...) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75872       };
75873     }
75874   }
75875
75876 }
75877
75878
75879 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75880   float jresult ;
75881   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75882   float result;
75883
75884   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75885   {
75886     try {
75887       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75888     } catch (std::out_of_range& e) {
75889       {
75890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75891       };
75892     } catch (std::exception& e) {
75893       {
75894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75895       };
75896     } catch (Dali::DaliException e) {
75897       {
75898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75899       };
75900     } catch (...) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75903       };
75904     }
75905   }
75906
75907   jresult = result;
75908   return jresult;
75909 }
75910
75911
75912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75913   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75914   float arg2 ;
75915
75916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75917   arg2 = (float)jarg2;
75918   {
75919     try {
75920       (arg1)->SetMaxFlickSpeed(arg2);
75921     } catch (std::out_of_range& e) {
75922       {
75923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75924       };
75925     } catch (std::exception& e) {
75926       {
75927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75928       };
75929     } catch (Dali::DaliException e) {
75930       {
75931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75932       };
75933     } catch (...) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75936       };
75937     }
75938   }
75939
75940 }
75941
75942
75943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75944   void * jresult ;
75945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75946   Dali::Vector2 result;
75947
75948   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75949   {
75950     try {
75951       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75952     } catch (std::out_of_range& e) {
75953       {
75954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75955       };
75956     } catch (std::exception& e) {
75957       {
75958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75959       };
75960     } catch (Dali::DaliException e) {
75961       {
75962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75963       };
75964     } catch (...) {
75965       {
75966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75967       };
75968     }
75969   }
75970
75971   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75972   return jresult;
75973 }
75974
75975
75976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75977   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75978   Dali::Vector2 arg2 ;
75979   Dali::Vector2 *argp2 ;
75980
75981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75982   argp2 = (Dali::Vector2 *)jarg2;
75983   if (!argp2) {
75984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75985     return ;
75986   }
75987   arg2 = *argp2;
75988   {
75989     try {
75990       (arg1)->SetWheelScrollDistanceStep(arg2);
75991     } catch (std::out_of_range& e) {
75992       {
75993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75994       };
75995     } catch (std::exception& e) {
75996       {
75997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75998       };
75999     } catch (Dali::DaliException e) {
76000       {
76001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76002       };
76003     } catch (...) {
76004       {
76005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76006       };
76007     }
76008   }
76009
76010 }
76011
76012
76013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
76014   void * jresult ;
76015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76016   Dali::Vector2 result;
76017
76018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76019   {
76020     try {
76021       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
76022     } catch (std::out_of_range& e) {
76023       {
76024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76025       };
76026     } catch (std::exception& e) {
76027       {
76028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76029       };
76030     } catch (Dali::DaliException e) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76033       };
76034     } catch (...) {
76035       {
76036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76037       };
76038     }
76039   }
76040
76041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76042   return jresult;
76043 }
76044
76045
76046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
76047   unsigned int jresult ;
76048   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76049   unsigned int result;
76050
76051   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76052   {
76053     try {
76054       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
76055     } catch (std::out_of_range& e) {
76056       {
76057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76058       };
76059     } catch (std::exception& e) {
76060       {
76061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76062       };
76063     } catch (Dali::DaliException e) {
76064       {
76065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76066       };
76067     } catch (...) {
76068       {
76069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76070       };
76071     }
76072   }
76073
76074   jresult = result;
76075   return jresult;
76076 }
76077
76078
76079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76081   Dali::Vector2 *arg2 = 0 ;
76082
76083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76084   arg2 = (Dali::Vector2 *)jarg2;
76085   if (!arg2) {
76086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76087     return ;
76088   }
76089   {
76090     try {
76091       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76092     } catch (std::out_of_range& e) {
76093       {
76094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76095       };
76096     } catch (std::exception& e) {
76097       {
76098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (Dali::DaliException e) {
76101       {
76102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76103       };
76104     } catch (...) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76107       };
76108     }
76109   }
76110
76111 }
76112
76113
76114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76115   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76116   Dali::Vector2 *arg2 = 0 ;
76117   float arg3 ;
76118
76119   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76120   arg2 = (Dali::Vector2 *)jarg2;
76121   if (!arg2) {
76122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76123     return ;
76124   }
76125   arg3 = (float)jarg3;
76126   {
76127     try {
76128       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76129     } catch (std::out_of_range& e) {
76130       {
76131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76132       };
76133     } catch (std::exception& e) {
76134       {
76135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76136       };
76137     } catch (Dali::DaliException e) {
76138       {
76139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76140       };
76141     } catch (...) {
76142       {
76143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76144       };
76145     }
76146   }
76147
76148 }
76149
76150
76151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76152   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76153   Dali::Vector2 *arg2 = 0 ;
76154   float arg3 ;
76155   Dali::AlphaFunction arg4 ;
76156   Dali::AlphaFunction *argp4 ;
76157
76158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76159   arg2 = (Dali::Vector2 *)jarg2;
76160   if (!arg2) {
76161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76162     return ;
76163   }
76164   arg3 = (float)jarg3;
76165   argp4 = (Dali::AlphaFunction *)jarg4;
76166   if (!argp4) {
76167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76168     return ;
76169   }
76170   arg4 = *argp4;
76171   {
76172     try {
76173       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76174     } catch (std::out_of_range& e) {
76175       {
76176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76177       };
76178     } catch (std::exception& e) {
76179       {
76180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76181       };
76182     } catch (Dali::DaliException e) {
76183       {
76184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76185       };
76186     } catch (...) {
76187       {
76188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76189       };
76190     }
76191   }
76192
76193 }
76194
76195
76196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76197   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76198   Dali::Vector2 *arg2 = 0 ;
76199   float arg3 ;
76200   Dali::Toolkit::DirectionBias arg4 ;
76201   Dali::Toolkit::DirectionBias arg5 ;
76202
76203   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76204   arg2 = (Dali::Vector2 *)jarg2;
76205   if (!arg2) {
76206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76207     return ;
76208   }
76209   arg3 = (float)jarg3;
76210   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76211   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76212   {
76213     try {
76214       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76215     } catch (std::out_of_range& e) {
76216       {
76217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76218       };
76219     } catch (std::exception& e) {
76220       {
76221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76222       };
76223     } catch (Dali::DaliException e) {
76224       {
76225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76226       };
76227     } catch (...) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76230       };
76231     }
76232   }
76233
76234 }
76235
76236
76237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76239   Dali::Vector2 *arg2 = 0 ;
76240   float arg3 ;
76241   Dali::AlphaFunction arg4 ;
76242   Dali::Toolkit::DirectionBias arg5 ;
76243   Dali::Toolkit::DirectionBias arg6 ;
76244   Dali::AlphaFunction *argp4 ;
76245
76246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76247   arg2 = (Dali::Vector2 *)jarg2;
76248   if (!arg2) {
76249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76250     return ;
76251   }
76252   arg3 = (float)jarg3;
76253   argp4 = (Dali::AlphaFunction *)jarg4;
76254   if (!argp4) {
76255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76256     return ;
76257   }
76258   arg4 = *argp4;
76259   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76260   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76261   {
76262     try {
76263       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76264     } catch (std::out_of_range& e) {
76265       {
76266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76267       };
76268     } catch (std::exception& e) {
76269       {
76270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76271       };
76272     } catch (Dali::DaliException e) {
76273       {
76274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76275       };
76276     } catch (...) {
76277       {
76278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76279       };
76280     }
76281   }
76282
76283 }
76284
76285
76286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76288   unsigned int arg2 ;
76289
76290   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76291   arg2 = (unsigned int)jarg2;
76292   {
76293     try {
76294       (arg1)->ScrollTo(arg2);
76295     } catch (std::out_of_range& e) {
76296       {
76297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76298       };
76299     } catch (std::exception& e) {
76300       {
76301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76302       };
76303     } catch (Dali::DaliException e) {
76304       {
76305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76306       };
76307     } catch (...) {
76308       {
76309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76310       };
76311     }
76312   }
76313
76314 }
76315
76316
76317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76319   unsigned int arg2 ;
76320   float arg3 ;
76321
76322   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76323   arg2 = (unsigned int)jarg2;
76324   arg3 = (float)jarg3;
76325   {
76326     try {
76327       (arg1)->ScrollTo(arg2,arg3);
76328     } catch (std::out_of_range& e) {
76329       {
76330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76331       };
76332     } catch (std::exception& e) {
76333       {
76334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76335       };
76336     } catch (Dali::DaliException e) {
76337       {
76338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76339       };
76340     } catch (...) {
76341       {
76342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76343       };
76344     }
76345   }
76346
76347 }
76348
76349
76350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76351   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76352   unsigned int arg2 ;
76353   float arg3 ;
76354   Dali::Toolkit::DirectionBias arg4 ;
76355
76356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76357   arg2 = (unsigned int)jarg2;
76358   arg3 = (float)jarg3;
76359   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76360   {
76361     try {
76362       (arg1)->ScrollTo(arg2,arg3,arg4);
76363     } catch (std::out_of_range& e) {
76364       {
76365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76366       };
76367     } catch (std::exception& e) {
76368       {
76369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76370       };
76371     } catch (Dali::DaliException e) {
76372       {
76373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76374       };
76375     } catch (...) {
76376       {
76377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76378       };
76379     }
76380   }
76381
76382 }
76383
76384
76385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76387   Dali::Actor *arg2 = 0 ;
76388
76389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76390   arg2 = (Dali::Actor *)jarg2;
76391   if (!arg2) {
76392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76393     return ;
76394   }
76395   {
76396     try {
76397       (arg1)->ScrollTo(*arg2);
76398     } catch (std::out_of_range& e) {
76399       {
76400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76401       };
76402     } catch (std::exception& e) {
76403       {
76404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76405       };
76406     } catch (Dali::DaliException e) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76409       };
76410     } catch (...) {
76411       {
76412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76413       };
76414     }
76415   }
76416
76417 }
76418
76419
76420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76421   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76422   Dali::Actor *arg2 = 0 ;
76423   float arg3 ;
76424
76425   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76426   arg2 = (Dali::Actor *)jarg2;
76427   if (!arg2) {
76428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76429     return ;
76430   }
76431   arg3 = (float)jarg3;
76432   {
76433     try {
76434       (arg1)->ScrollTo(*arg2,arg3);
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76442       };
76443     } catch (Dali::DaliException e) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76450       };
76451     }
76452   }
76453
76454 }
76455
76456
76457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76458   unsigned int jresult ;
76459   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76460   bool result;
76461
76462   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76463   {
76464     try {
76465       result = (bool)(arg1)->ScrollToSnapPoint();
76466     } catch (std::out_of_range& e) {
76467       {
76468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76469       };
76470     } catch (std::exception& e) {
76471       {
76472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76473       };
76474     } catch (Dali::DaliException e) {
76475       {
76476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76477       };
76478     } catch (...) {
76479       {
76480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76481       };
76482     }
76483   }
76484
76485   jresult = result;
76486   return jresult;
76487 }
76488
76489
76490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76492   Dali::Constraint arg2 ;
76493   Dali::Constraint *argp2 ;
76494
76495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76496   argp2 = (Dali::Constraint *)jarg2;
76497   if (!argp2) {
76498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76499     return ;
76500   }
76501   arg2 = *argp2;
76502   {
76503     try {
76504       (arg1)->ApplyConstraintToChildren(arg2);
76505     } catch (std::out_of_range& e) {
76506       {
76507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76508       };
76509     } catch (std::exception& e) {
76510       {
76511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76512       };
76513     } catch (Dali::DaliException e) {
76514       {
76515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76516       };
76517     } catch (...) {
76518       {
76519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76520       };
76521     }
76522   }
76523
76524 }
76525
76526
76527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76528   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76529
76530   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76531   {
76532     try {
76533       (arg1)->RemoveConstraintsFromChildren();
76534     } catch (std::out_of_range& e) {
76535       {
76536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76537       };
76538     } catch (std::exception& e) {
76539       {
76540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76541       };
76542     } catch (Dali::DaliException e) {
76543       {
76544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76545       };
76546     } catch (...) {
76547       {
76548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76549       };
76550     }
76551   }
76552
76553 }
76554
76555
76556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76558   Dali::Toolkit::ScrollViewEffect arg2 ;
76559   Dali::Toolkit::ScrollViewEffect *argp2 ;
76560
76561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76562   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76563   if (!argp2) {
76564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76565     return ;
76566   }
76567   arg2 = *argp2;
76568   {
76569     try {
76570       (arg1)->ApplyEffect(arg2);
76571     } catch (std::out_of_range& e) {
76572       {
76573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76574       };
76575     } catch (std::exception& e) {
76576       {
76577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76578       };
76579     } catch (Dali::DaliException e) {
76580       {
76581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76582       };
76583     } catch (...) {
76584       {
76585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76586       };
76587     }
76588   }
76589
76590 }
76591
76592
76593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76595   Dali::Toolkit::ScrollViewEffect arg2 ;
76596   Dali::Toolkit::ScrollViewEffect *argp2 ;
76597
76598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76599   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76600   if (!argp2) {
76601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76602     return ;
76603   }
76604   arg2 = *argp2;
76605   {
76606     try {
76607       (arg1)->RemoveEffect(arg2);
76608     } catch (std::out_of_range& e) {
76609       {
76610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76611       };
76612     } catch (std::exception& e) {
76613       {
76614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76615       };
76616     } catch (Dali::DaliException e) {
76617       {
76618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76619       };
76620     } catch (...) {
76621       {
76622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76623       };
76624     }
76625   }
76626
76627 }
76628
76629
76630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76631   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76632
76633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76634   {
76635     try {
76636       (arg1)->RemoveAllEffects();
76637     } catch (std::out_of_range& e) {
76638       {
76639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76640       };
76641     } catch (std::exception& e) {
76642       {
76643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76644       };
76645     } catch (Dali::DaliException e) {
76646       {
76647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76648       };
76649     } catch (...) {
76650       {
76651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76652       };
76653     }
76654   }
76655
76656 }
76657
76658
76659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76660   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76661   Dali::Actor arg2 ;
76662   Dali::Actor *argp2 ;
76663
76664   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76665   argp2 = (Dali::Actor *)jarg2;
76666   if (!argp2) {
76667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76668     return ;
76669   }
76670   arg2 = *argp2;
76671   {
76672     try {
76673       (arg1)->BindActor(arg2);
76674     } catch (std::out_of_range& e) {
76675       {
76676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76677       };
76678     } catch (std::exception& e) {
76679       {
76680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76681       };
76682     } catch (Dali::DaliException e) {
76683       {
76684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76685       };
76686     } catch (...) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76689       };
76690     }
76691   }
76692
76693 }
76694
76695
76696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76697   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76698   Dali::Actor arg2 ;
76699   Dali::Actor *argp2 ;
76700
76701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76702   argp2 = (Dali::Actor *)jarg2;
76703   if (!argp2) {
76704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76705     return ;
76706   }
76707   arg2 = *argp2;
76708   {
76709     try {
76710       (arg1)->UnbindActor(arg2);
76711     } catch (std::out_of_range& e) {
76712       {
76713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76714       };
76715     } catch (std::exception& e) {
76716       {
76717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76718       };
76719     } catch (Dali::DaliException e) {
76720       {
76721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76722       };
76723     } catch (...) {
76724       {
76725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76726       };
76727     }
76728   }
76729
76730 }
76731
76732
76733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76735   Dali::Radian arg2 ;
76736   Dali::Radian arg3 ;
76737   Dali::Radian *argp2 ;
76738   Dali::Radian *argp3 ;
76739
76740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76741   argp2 = (Dali::Radian *)jarg2;
76742   if (!argp2) {
76743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76744     return ;
76745   }
76746   arg2 = *argp2;
76747   argp3 = (Dali::Radian *)jarg3;
76748   if (!argp3) {
76749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76750     return ;
76751   }
76752   arg3 = *argp3;
76753   {
76754     try {
76755       (arg1)->SetScrollingDirection(arg2,arg3);
76756     } catch (std::out_of_range& e) {
76757       {
76758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76759       };
76760     } catch (std::exception& e) {
76761       {
76762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76763       };
76764     } catch (Dali::DaliException e) {
76765       {
76766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76767       };
76768     } catch (...) {
76769       {
76770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76771       };
76772     }
76773   }
76774
76775 }
76776
76777
76778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76780   Dali::Radian arg2 ;
76781   Dali::Radian *argp2 ;
76782
76783   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76784   argp2 = (Dali::Radian *)jarg2;
76785   if (!argp2) {
76786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76787     return ;
76788   }
76789   arg2 = *argp2;
76790   {
76791     try {
76792       (arg1)->SetScrollingDirection(arg2);
76793     } catch (std::out_of_range& e) {
76794       {
76795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76796       };
76797     } catch (std::exception& e) {
76798       {
76799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76800       };
76801     } catch (Dali::DaliException e) {
76802       {
76803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76804       };
76805     } catch (...) {
76806       {
76807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76808       };
76809     }
76810   }
76811
76812 }
76813
76814
76815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76816   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76817   Dali::Radian arg2 ;
76818   Dali::Radian *argp2 ;
76819
76820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76821   argp2 = (Dali::Radian *)jarg2;
76822   if (!argp2) {
76823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76824     return ;
76825   }
76826   arg2 = *argp2;
76827   {
76828     try {
76829       (arg1)->RemoveScrollingDirection(arg2);
76830     } catch (std::out_of_range& e) {
76831       {
76832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76833       };
76834     } catch (std::exception& e) {
76835       {
76836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76837       };
76838     } catch (Dali::DaliException e) {
76839       {
76840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76841       };
76842     } catch (...) {
76843       {
76844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76845       };
76846     }
76847   }
76848
76849 }
76850
76851
76852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76853   void * jresult ;
76854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76855   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76856
76857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76858   {
76859     try {
76860       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76861     } catch (std::out_of_range& e) {
76862       {
76863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76864       };
76865     } catch (std::exception& e) {
76866       {
76867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76868       };
76869     } catch (Dali::DaliException e) {
76870       {
76871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76872       };
76873     } catch (...) {
76874       {
76875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76876       };
76877     }
76878   }
76879
76880   jresult = (void *)result;
76881   return jresult;
76882 }
76883
76884
76885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76886   int jresult ;
76887   int result;
76888
76889   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76890   jresult = (int)result;
76891   return jresult;
76892 }
76893
76894
76895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76896   int jresult ;
76897   int result;
76898
76899   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76900   jresult = (int)result;
76901   return jresult;
76902 }
76903
76904
76905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76906   int jresult ;
76907   int result;
76908
76909   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76910   jresult = (int)result;
76911   return jresult;
76912 }
76913
76914
76915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76916   int jresult ;
76917   int result;
76918
76919   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76920   jresult = (int)result;
76921   return jresult;
76922 }
76923
76924
76925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76926   int jresult ;
76927   int result;
76928
76929   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76930   jresult = (int)result;
76931   return jresult;
76932 }
76933
76934
76935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76936   void * jresult ;
76937   Dali::Toolkit::TableView::Property *result = 0 ;
76938
76939   {
76940     try {
76941       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76942     } catch (std::out_of_range& e) {
76943       {
76944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76945       };
76946     } catch (std::exception& e) {
76947       {
76948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76949       };
76950     } catch (Dali::DaliException e) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76953       };
76954     } catch (...) {
76955       {
76956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76957       };
76958     }
76959   }
76960
76961   jresult = (void *)result;
76962   return jresult;
76963 }
76964
76965
76966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76967   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76968
76969   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76970   {
76971     try {
76972       delete arg1;
76973     } catch (std::out_of_range& e) {
76974       {
76975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76976       };
76977     } catch (std::exception& e) {
76978       {
76979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76980       };
76981     } catch (Dali::DaliException e) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76984       };
76985     } catch (...) {
76986       {
76987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76988       };
76989     }
76990   }
76991
76992 }
76993
76994
76995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76996   int jresult ;
76997   int result;
76998
76999   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
77000   jresult = (int)result;
77001   return jresult;
77002 }
77003
77004
77005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
77006   int jresult ;
77007   int result;
77008
77009   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
77010   jresult = (int)result;
77011   return jresult;
77012 }
77013
77014
77015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
77016   int jresult ;
77017   int result;
77018
77019   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
77020   jresult = (int)result;
77021   return jresult;
77022 }
77023
77024
77025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
77026   int jresult ;
77027   int result;
77028
77029   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
77030   jresult = (int)result;
77031   return jresult;
77032 }
77033
77034
77035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
77036   int jresult ;
77037   int result;
77038
77039   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
77040   jresult = (int)result;
77041   return jresult;
77042 }
77043
77044
77045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
77046   void * jresult ;
77047   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
77048
77049   {
77050     try {
77051       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
77052     } catch (std::out_of_range& e) {
77053       {
77054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77055       };
77056     } catch (std::exception& e) {
77057       {
77058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77059       };
77060     } catch (Dali::DaliException e) {
77061       {
77062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77063       };
77064     } catch (...) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77067       };
77068     }
77069   }
77070
77071   jresult = (void *)result;
77072   return jresult;
77073 }
77074
77075
77076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77077   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77078
77079   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77080   {
77081     try {
77082       delete arg1;
77083     } catch (std::out_of_range& e) {
77084       {
77085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77086       };
77087     } catch (std::exception& e) {
77088       {
77089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77090       };
77091     } catch (Dali::DaliException e) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77094       };
77095     } catch (...) {
77096       {
77097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77098       };
77099     }
77100   }
77101
77102 }
77103
77104
77105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77106   void * jresult ;
77107   unsigned int arg1 ;
77108   unsigned int arg2 ;
77109   unsigned int arg3 ;
77110   unsigned int arg4 ;
77111   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77112
77113   arg1 = (unsigned int)jarg1;
77114   arg2 = (unsigned int)jarg2;
77115   arg3 = (unsigned int)jarg3;
77116   arg4 = (unsigned int)jarg4;
77117   {
77118     try {
77119       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77120     } catch (std::out_of_range& e) {
77121       {
77122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77123       };
77124     } catch (std::exception& e) {
77125       {
77126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77127       };
77128     } catch (Dali::DaliException e) {
77129       {
77130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77131       };
77132     } catch (...) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77135       };
77136     }
77137   }
77138
77139   jresult = (void *)result;
77140   return jresult;
77141 }
77142
77143
77144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77145   void * jresult ;
77146   unsigned int arg1 ;
77147   unsigned int arg2 ;
77148   unsigned int arg3 ;
77149   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77150
77151   arg1 = (unsigned int)jarg1;
77152   arg2 = (unsigned int)jarg2;
77153   arg3 = (unsigned int)jarg3;
77154   {
77155     try {
77156       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77157     } catch (std::out_of_range& e) {
77158       {
77159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77160       };
77161     } catch (std::exception& e) {
77162       {
77163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77164       };
77165     } catch (Dali::DaliException e) {
77166       {
77167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77168       };
77169     } catch (...) {
77170       {
77171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77172       };
77173     }
77174   }
77175
77176   jresult = (void *)result;
77177   return jresult;
77178 }
77179
77180
77181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77182   void * jresult ;
77183   unsigned int arg1 ;
77184   unsigned int arg2 ;
77185   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77186
77187   arg1 = (unsigned int)jarg1;
77188   arg2 = (unsigned int)jarg2;
77189   {
77190     try {
77191       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77192     } catch (std::out_of_range& e) {
77193       {
77194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77195       };
77196     } catch (std::exception& e) {
77197       {
77198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77199       };
77200     } catch (Dali::DaliException e) {
77201       {
77202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77203       };
77204     } catch (...) {
77205       {
77206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77207       };
77208     }
77209   }
77210
77211   jresult = (void *)result;
77212   return jresult;
77213 }
77214
77215
77216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77217   void * jresult ;
77218   unsigned int arg1 ;
77219   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77220
77221   arg1 = (unsigned int)jarg1;
77222   {
77223     try {
77224       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77225     } catch (std::out_of_range& e) {
77226       {
77227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77228       };
77229     } catch (std::exception& e) {
77230       {
77231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77232       };
77233     } catch (Dali::DaliException e) {
77234       {
77235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77236       };
77237     } catch (...) {
77238       {
77239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77240       };
77241     }
77242   }
77243
77244   jresult = (void *)result;
77245   return jresult;
77246 }
77247
77248
77249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77250   void * jresult ;
77251   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77252
77253   {
77254     try {
77255       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77256     } catch (std::out_of_range& e) {
77257       {
77258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77259       };
77260     } catch (std::exception& e) {
77261       {
77262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77263       };
77264     } catch (Dali::DaliException e) {
77265       {
77266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77267       };
77268     } catch (...) {
77269       {
77270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77271       };
77272     }
77273   }
77274
77275   jresult = (void *)result;
77276   return jresult;
77277 }
77278
77279
77280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77281   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77282   unsigned int arg2 ;
77283
77284   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77285   arg2 = (unsigned int)jarg2;
77286   if (arg1) (arg1)->rowIndex = arg2;
77287 }
77288
77289
77290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77291   unsigned int jresult ;
77292   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77293   unsigned int result;
77294
77295   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77296   result = (unsigned int) ((arg1)->rowIndex);
77297   jresult = result;
77298   return jresult;
77299 }
77300
77301
77302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77303   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77304   unsigned int arg2 ;
77305
77306   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77307   arg2 = (unsigned int)jarg2;
77308   if (arg1) (arg1)->columnIndex = arg2;
77309 }
77310
77311
77312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77313   unsigned int jresult ;
77314   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77315   unsigned int result;
77316
77317   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77318   result = (unsigned int) ((arg1)->columnIndex);
77319   jresult = result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77325   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77326   unsigned int arg2 ;
77327
77328   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77329   arg2 = (unsigned int)jarg2;
77330   if (arg1) (arg1)->rowSpan = arg2;
77331 }
77332
77333
77334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77335   unsigned int jresult ;
77336   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77337   unsigned int result;
77338
77339   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77340   result = (unsigned int) ((arg1)->rowSpan);
77341   jresult = result;
77342   return jresult;
77343 }
77344
77345
77346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77347   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77348   unsigned int arg2 ;
77349
77350   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77351   arg2 = (unsigned int)jarg2;
77352   if (arg1) (arg1)->columnSpan = arg2;
77353 }
77354
77355
77356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77357   unsigned int jresult ;
77358   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77359   unsigned int result;
77360
77361   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77362   result = (unsigned int) ((arg1)->columnSpan);
77363   jresult = result;
77364   return jresult;
77365 }
77366
77367
77368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77369   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77370
77371   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77372   {
77373     try {
77374       delete arg1;
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77382       };
77383     } catch (Dali::DaliException e) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77386       };
77387     } catch (...) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77390       };
77391     }
77392   }
77393
77394 }
77395
77396
77397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77398   void * jresult ;
77399   Dali::Toolkit::TableView *result = 0 ;
77400
77401   {
77402     try {
77403       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77404     } catch (std::out_of_range& e) {
77405       {
77406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77407       };
77408     } catch (std::exception& e) {
77409       {
77410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77411       };
77412     } catch (Dali::DaliException e) {
77413       {
77414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77415       };
77416     } catch (...) {
77417       {
77418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77419       };
77420     }
77421   }
77422
77423   jresult = (void *)result;
77424   return jresult;
77425 }
77426
77427
77428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77429   void * jresult ;
77430   Dali::Toolkit::TableView *arg1 = 0 ;
77431   Dali::Toolkit::TableView *result = 0 ;
77432
77433   arg1 = (Dali::Toolkit::TableView *)jarg1;
77434   if (!arg1) {
77435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77436     return 0;
77437   }
77438   {
77439     try {
77440       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77441     } catch (std::out_of_range& e) {
77442       {
77443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77444       };
77445     } catch (std::exception& e) {
77446       {
77447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77448       };
77449     } catch (Dali::DaliException e) {
77450       {
77451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77452       };
77453     } catch (...) {
77454       {
77455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77456       };
77457     }
77458   }
77459
77460   jresult = (void *)result;
77461   return jresult;
77462 }
77463
77464
77465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77466   void * jresult ;
77467   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77468   Dali::Toolkit::TableView *arg2 = 0 ;
77469   Dali::Toolkit::TableView *result = 0 ;
77470
77471   arg1 = (Dali::Toolkit::TableView *)jarg1;
77472   arg2 = (Dali::Toolkit::TableView *)jarg2;
77473   if (!arg2) {
77474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77475     return 0;
77476   }
77477   {
77478     try {
77479       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77480     } catch (std::out_of_range& e) {
77481       {
77482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77483       };
77484     } catch (std::exception& e) {
77485       {
77486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77487       };
77488     } catch (Dali::DaliException e) {
77489       {
77490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77491       };
77492     } catch (...) {
77493       {
77494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77495       };
77496     }
77497   }
77498
77499   jresult = (void *)result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77506
77507   arg1 = (Dali::Toolkit::TableView *)jarg1;
77508   {
77509     try {
77510       delete arg1;
77511     } catch (std::out_of_range& e) {
77512       {
77513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77514       };
77515     } catch (std::exception& e) {
77516       {
77517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77518       };
77519     } catch (Dali::DaliException e) {
77520       {
77521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77522       };
77523     } catch (...) {
77524       {
77525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77526       };
77527     }
77528   }
77529
77530 }
77531
77532
77533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77534   void * jresult ;
77535   unsigned int arg1 ;
77536   unsigned int arg2 ;
77537   Dali::Toolkit::TableView result;
77538
77539   arg1 = (unsigned int)jarg1;
77540   arg2 = (unsigned int)jarg2;
77541   {
77542     try {
77543       result = Dali::Toolkit::TableView::New(arg1,arg2);
77544     } catch (std::out_of_range& e) {
77545       {
77546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77547       };
77548     } catch (std::exception& e) {
77549       {
77550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77551       };
77552     } catch (Dali::DaliException e) {
77553       {
77554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77555       };
77556     } catch (...) {
77557       {
77558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77559       };
77560     }
77561   }
77562
77563   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77569   void * jresult ;
77570   Dali::BaseHandle arg1 ;
77571   Dali::BaseHandle *argp1 ;
77572   Dali::Toolkit::TableView result;
77573
77574   argp1 = (Dali::BaseHandle *)jarg1;
77575   if (!argp1) {
77576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77577     return 0;
77578   }
77579   arg1 = *argp1;
77580   {
77581     try {
77582       result = Dali::Toolkit::TableView::DownCast(arg1);
77583     } catch (std::out_of_range& e) {
77584       {
77585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77586       };
77587     } catch (std::exception& e) {
77588       {
77589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77590       };
77591     } catch (Dali::DaliException e) {
77592       {
77593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77594       };
77595     } catch (...) {
77596       {
77597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77598       };
77599     }
77600   }
77601
77602   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77603   return jresult;
77604 }
77605
77606
77607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77608   unsigned int jresult ;
77609   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77610   Dali::Actor arg2 ;
77611   Dali::Toolkit::TableView::CellPosition arg3 ;
77612   Dali::Actor *argp2 ;
77613   Dali::Toolkit::TableView::CellPosition *argp3 ;
77614   bool result;
77615
77616   arg1 = (Dali::Toolkit::TableView *)jarg1;
77617   argp2 = (Dali::Actor *)jarg2;
77618   if (!argp2) {
77619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77620     return 0;
77621   }
77622   arg2 = *argp2;
77623   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77624   if (!argp3) {
77625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77626     return 0;
77627   }
77628   arg3 = *argp3;
77629   {
77630     try {
77631       result = (bool)(arg1)->AddChild(arg2,arg3);
77632     } catch (std::out_of_range& e) {
77633       {
77634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77635       };
77636     } catch (std::exception& e) {
77637       {
77638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77639       };
77640     } catch (Dali::DaliException e) {
77641       {
77642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77643       };
77644     } catch (...) {
77645       {
77646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77647       };
77648     }
77649   }
77650
77651   jresult = result;
77652   return jresult;
77653 }
77654
77655
77656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77657   void * jresult ;
77658   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77659   Dali::Toolkit::TableView::CellPosition arg2 ;
77660   Dali::Toolkit::TableView::CellPosition *argp2 ;
77661   Dali::Actor result;
77662
77663   arg1 = (Dali::Toolkit::TableView *)jarg1;
77664   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77665   if (!argp2) {
77666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77667     return 0;
77668   }
77669   arg2 = *argp2;
77670   {
77671     try {
77672       result = (arg1)->GetChildAt(arg2);
77673     } catch (std::out_of_range& e) {
77674       {
77675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77676       };
77677     } catch (std::exception& e) {
77678       {
77679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77680       };
77681     } catch (Dali::DaliException e) {
77682       {
77683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77684       };
77685     } catch (...) {
77686       {
77687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77688       };
77689     }
77690   }
77691
77692   jresult = new Dali::Actor((const Dali::Actor &)result);
77693   return jresult;
77694 }
77695
77696
77697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77698   void * jresult ;
77699   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77700   Dali::Toolkit::TableView::CellPosition arg2 ;
77701   Dali::Toolkit::TableView::CellPosition *argp2 ;
77702   Dali::Actor result;
77703
77704   arg1 = (Dali::Toolkit::TableView *)jarg1;
77705   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77706   if (!argp2) {
77707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77708     return 0;
77709   }
77710   arg2 = *argp2;
77711   {
77712     try {
77713       result = (arg1)->RemoveChildAt(arg2);
77714     } catch (std::out_of_range& e) {
77715       {
77716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77717       };
77718     } catch (std::exception& e) {
77719       {
77720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77721       };
77722     } catch (Dali::DaliException e) {
77723       {
77724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77725       };
77726     } catch (...) {
77727       {
77728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77729       };
77730     }
77731   }
77732
77733   jresult = new Dali::Actor((const Dali::Actor &)result);
77734   return jresult;
77735 }
77736
77737
77738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77739   unsigned int jresult ;
77740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77741   Dali::Actor arg2 ;
77742   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77743   Dali::Actor *argp2 ;
77744   bool result;
77745
77746   arg1 = (Dali::Toolkit::TableView *)jarg1;
77747   argp2 = (Dali::Actor *)jarg2;
77748   if (!argp2) {
77749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77750     return 0;
77751   }
77752   arg2 = *argp2;
77753   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77754   if (!arg3) {
77755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77756     return 0;
77757   }
77758   {
77759     try {
77760       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77761     } catch (std::out_of_range& e) {
77762       {
77763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77764       };
77765     } catch (std::exception& e) {
77766       {
77767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77768       };
77769     } catch (Dali::DaliException e) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77772       };
77773     } catch (...) {
77774       {
77775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77776       };
77777     }
77778   }
77779
77780   jresult = result;
77781   return jresult;
77782 }
77783
77784
77785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77786   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77787   unsigned int arg2 ;
77788
77789   arg1 = (Dali::Toolkit::TableView *)jarg1;
77790   arg2 = (unsigned int)jarg2;
77791   {
77792     try {
77793       (arg1)->InsertRow(arg2);
77794     } catch (std::out_of_range& e) {
77795       {
77796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77797       };
77798     } catch (std::exception& e) {
77799       {
77800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77801       };
77802     } catch (Dali::DaliException e) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77805       };
77806     } catch (...) {
77807       {
77808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77809       };
77810     }
77811   }
77812
77813 }
77814
77815
77816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77817   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77818   unsigned int arg2 ;
77819
77820   arg1 = (Dali::Toolkit::TableView *)jarg1;
77821   arg2 = (unsigned int)jarg2;
77822   {
77823     try {
77824       (arg1)->DeleteRow(arg2);
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77840       };
77841     }
77842   }
77843
77844 }
77845
77846
77847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77848   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77849   unsigned int arg2 ;
77850   std::vector< Dali::Actor > *arg3 = 0 ;
77851
77852   arg1 = (Dali::Toolkit::TableView *)jarg1;
77853   arg2 = (unsigned int)jarg2;
77854   arg3 = (std::vector< Dali::Actor > *)jarg3;
77855   if (!arg3) {
77856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77857     return ;
77858   }
77859   {
77860     try {
77861       (arg1)->DeleteRow(arg2,*arg3);
77862     } catch (std::out_of_range& e) {
77863       {
77864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77865       };
77866     } catch (std::exception& e) {
77867       {
77868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77869       };
77870     } catch (Dali::DaliException e) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77873       };
77874     } catch (...) {
77875       {
77876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77877       };
77878     }
77879   }
77880
77881 }
77882
77883
77884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77885   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77886   unsigned int arg2 ;
77887
77888   arg1 = (Dali::Toolkit::TableView *)jarg1;
77889   arg2 = (unsigned int)jarg2;
77890   {
77891     try {
77892       (arg1)->InsertColumn(arg2);
77893     } catch (std::out_of_range& e) {
77894       {
77895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77896       };
77897     } catch (std::exception& e) {
77898       {
77899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77900       };
77901     } catch (Dali::DaliException e) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77904       };
77905     } catch (...) {
77906       {
77907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77908       };
77909     }
77910   }
77911
77912 }
77913
77914
77915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77916   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77917   unsigned int arg2 ;
77918
77919   arg1 = (Dali::Toolkit::TableView *)jarg1;
77920   arg2 = (unsigned int)jarg2;
77921   {
77922     try {
77923       (arg1)->DeleteColumn(arg2);
77924     } catch (std::out_of_range& e) {
77925       {
77926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77927       };
77928     } catch (std::exception& e) {
77929       {
77930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77931       };
77932     } catch (Dali::DaliException e) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77935       };
77936     } catch (...) {
77937       {
77938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77939       };
77940     }
77941   }
77942
77943 }
77944
77945
77946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77948   unsigned int arg2 ;
77949   std::vector< Dali::Actor > *arg3 = 0 ;
77950
77951   arg1 = (Dali::Toolkit::TableView *)jarg1;
77952   arg2 = (unsigned int)jarg2;
77953   arg3 = (std::vector< Dali::Actor > *)jarg3;
77954   if (!arg3) {
77955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77956     return ;
77957   }
77958   {
77959     try {
77960       (arg1)->DeleteColumn(arg2,*arg3);
77961     } catch (std::out_of_range& e) {
77962       {
77963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77964       };
77965     } catch (std::exception& e) {
77966       {
77967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77968       };
77969     } catch (Dali::DaliException e) {
77970       {
77971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77972       };
77973     } catch (...) {
77974       {
77975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77976       };
77977     }
77978   }
77979
77980 }
77981
77982
77983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77984   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77985   unsigned int arg2 ;
77986   unsigned int arg3 ;
77987
77988   arg1 = (Dali::Toolkit::TableView *)jarg1;
77989   arg2 = (unsigned int)jarg2;
77990   arg3 = (unsigned int)jarg3;
77991   {
77992     try {
77993       (arg1)->Resize(arg2,arg3);
77994     } catch (std::out_of_range& e) {
77995       {
77996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77997       };
77998     } catch (std::exception& e) {
77999       {
78000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78001       };
78002     } catch (Dali::DaliException e) {
78003       {
78004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78005       };
78006     } catch (...) {
78007       {
78008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78009       };
78010     }
78011   }
78012
78013 }
78014
78015
78016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
78017   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78018   unsigned int arg2 ;
78019   unsigned int arg3 ;
78020   std::vector< Dali::Actor > *arg4 = 0 ;
78021
78022   arg1 = (Dali::Toolkit::TableView *)jarg1;
78023   arg2 = (unsigned int)jarg2;
78024   arg3 = (unsigned int)jarg3;
78025   arg4 = (std::vector< Dali::Actor > *)jarg4;
78026   if (!arg4) {
78027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78028     return ;
78029   }
78030   {
78031     try {
78032       (arg1)->Resize(arg2,arg3,*arg4);
78033     } catch (std::out_of_range& e) {
78034       {
78035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78036       };
78037     } catch (std::exception& e) {
78038       {
78039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78040       };
78041     } catch (Dali::DaliException e) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78044       };
78045     } catch (...) {
78046       {
78047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78048       };
78049     }
78050   }
78051
78052 }
78053
78054
78055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
78056   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78057   Dali::Size arg2 ;
78058   Dali::Size *argp2 ;
78059
78060   arg1 = (Dali::Toolkit::TableView *)jarg1;
78061   argp2 = (Dali::Size *)jarg2;
78062   if (!argp2) {
78063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78064     return ;
78065   }
78066   arg2 = *argp2;
78067   {
78068     try {
78069       (arg1)->SetCellPadding(arg2);
78070     } catch (std::out_of_range& e) {
78071       {
78072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78073       };
78074     } catch (std::exception& e) {
78075       {
78076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78077       };
78078     } catch (Dali::DaliException e) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78081       };
78082     } catch (...) {
78083       {
78084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78085       };
78086     }
78087   }
78088
78089 }
78090
78091
78092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78093   void * jresult ;
78094   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78095   Dali::Size result;
78096
78097   arg1 = (Dali::Toolkit::TableView *)jarg1;
78098   {
78099     try {
78100       result = (arg1)->GetCellPadding();
78101     } catch (std::out_of_range& e) {
78102       {
78103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78104       };
78105     } catch (std::exception& e) {
78106       {
78107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78108       };
78109     } catch (Dali::DaliException e) {
78110       {
78111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78112       };
78113     } catch (...) {
78114       {
78115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78116       };
78117     }
78118   }
78119
78120   jresult = new Dali::Size((const Dali::Size &)result);
78121   return jresult;
78122 }
78123
78124
78125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78126   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78127   unsigned int arg2 ;
78128
78129   arg1 = (Dali::Toolkit::TableView *)jarg1;
78130   arg2 = (unsigned int)jarg2;
78131   {
78132     try {
78133       (arg1)->SetFitHeight(arg2);
78134     } catch (std::out_of_range& e) {
78135       {
78136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78137       };
78138     } catch (std::exception& e) {
78139       {
78140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78141       };
78142     } catch (Dali::DaliException e) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78145       };
78146     } catch (...) {
78147       {
78148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78149       };
78150     }
78151   }
78152
78153 }
78154
78155
78156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78157   unsigned int jresult ;
78158   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78159   unsigned int arg2 ;
78160   bool result;
78161
78162   arg1 = (Dali::Toolkit::TableView *)jarg1;
78163   arg2 = (unsigned int)jarg2;
78164   {
78165     try {
78166       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78167     } catch (std::out_of_range& e) {
78168       {
78169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78170       };
78171     } catch (std::exception& e) {
78172       {
78173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78174       };
78175     } catch (Dali::DaliException e) {
78176       {
78177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78178       };
78179     } catch (...) {
78180       {
78181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78182       };
78183     }
78184   }
78185
78186   jresult = result;
78187   return jresult;
78188 }
78189
78190
78191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78192   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78193   unsigned int arg2 ;
78194
78195   arg1 = (Dali::Toolkit::TableView *)jarg1;
78196   arg2 = (unsigned int)jarg2;
78197   {
78198     try {
78199       (arg1)->SetFitWidth(arg2);
78200     } catch (std::out_of_range& e) {
78201       {
78202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78203       };
78204     } catch (std::exception& e) {
78205       {
78206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78207       };
78208     } catch (Dali::DaliException e) {
78209       {
78210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78211       };
78212     } catch (...) {
78213       {
78214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78215       };
78216     }
78217   }
78218
78219 }
78220
78221
78222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78223   unsigned int jresult ;
78224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78225   unsigned int arg2 ;
78226   bool result;
78227
78228   arg1 = (Dali::Toolkit::TableView *)jarg1;
78229   arg2 = (unsigned int)jarg2;
78230   {
78231     try {
78232       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78233     } catch (std::out_of_range& e) {
78234       {
78235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78236       };
78237     } catch (std::exception& e) {
78238       {
78239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78240       };
78241     } catch (Dali::DaliException e) {
78242       {
78243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78244       };
78245     } catch (...) {
78246       {
78247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78248       };
78249     }
78250   }
78251
78252   jresult = result;
78253   return jresult;
78254 }
78255
78256
78257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78258   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78259   unsigned int arg2 ;
78260   float arg3 ;
78261
78262   arg1 = (Dali::Toolkit::TableView *)jarg1;
78263   arg2 = (unsigned int)jarg2;
78264   arg3 = (float)jarg3;
78265   {
78266     try {
78267       (arg1)->SetFixedHeight(arg2,arg3);
78268     } catch (std::out_of_range& e) {
78269       {
78270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78271       };
78272     } catch (std::exception& e) {
78273       {
78274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78275       };
78276     } catch (Dali::DaliException e) {
78277       {
78278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78279       };
78280     } catch (...) {
78281       {
78282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78283       };
78284     }
78285   }
78286
78287 }
78288
78289
78290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78291   float jresult ;
78292   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78293   unsigned int arg2 ;
78294   float result;
78295
78296   arg1 = (Dali::Toolkit::TableView *)jarg1;
78297   arg2 = (unsigned int)jarg2;
78298   {
78299     try {
78300       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78301     } catch (std::out_of_range& e) {
78302       {
78303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78304       };
78305     } catch (std::exception& e) {
78306       {
78307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78308       };
78309     } catch (Dali::DaliException e) {
78310       {
78311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78312       };
78313     } catch (...) {
78314       {
78315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78316       };
78317     }
78318   }
78319
78320   jresult = result;
78321   return jresult;
78322 }
78323
78324
78325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78326   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78327   unsigned int arg2 ;
78328   float arg3 ;
78329
78330   arg1 = (Dali::Toolkit::TableView *)jarg1;
78331   arg2 = (unsigned int)jarg2;
78332   arg3 = (float)jarg3;
78333   {
78334     try {
78335       (arg1)->SetRelativeHeight(arg2,arg3);
78336     } catch (std::out_of_range& e) {
78337       {
78338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78339       };
78340     } catch (std::exception& e) {
78341       {
78342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78343       };
78344     } catch (Dali::DaliException e) {
78345       {
78346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78347       };
78348     } catch (...) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78351       };
78352     }
78353   }
78354
78355 }
78356
78357
78358 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78359   float jresult ;
78360   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78361   unsigned int arg2 ;
78362   float result;
78363
78364   arg1 = (Dali::Toolkit::TableView *)jarg1;
78365   arg2 = (unsigned int)jarg2;
78366   {
78367     try {
78368       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78369     } catch (std::out_of_range& e) {
78370       {
78371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78372       };
78373     } catch (std::exception& e) {
78374       {
78375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78376       };
78377     } catch (Dali::DaliException e) {
78378       {
78379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78380       };
78381     } catch (...) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78384       };
78385     }
78386   }
78387
78388   jresult = result;
78389   return jresult;
78390 }
78391
78392
78393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78394   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78395   unsigned int arg2 ;
78396   float arg3 ;
78397
78398   arg1 = (Dali::Toolkit::TableView *)jarg1;
78399   arg2 = (unsigned int)jarg2;
78400   arg3 = (float)jarg3;
78401   {
78402     try {
78403       (arg1)->SetFixedWidth(arg2,arg3);
78404     } catch (std::out_of_range& e) {
78405       {
78406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78407       };
78408     } catch (std::exception& e) {
78409       {
78410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78411       };
78412     } catch (Dali::DaliException e) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78415       };
78416     } catch (...) {
78417       {
78418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78419       };
78420     }
78421   }
78422
78423 }
78424
78425
78426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78427   float jresult ;
78428   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78429   unsigned int arg2 ;
78430   float result;
78431
78432   arg1 = (Dali::Toolkit::TableView *)jarg1;
78433   arg2 = (unsigned int)jarg2;
78434   {
78435     try {
78436       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78437     } catch (std::out_of_range& e) {
78438       {
78439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78440       };
78441     } catch (std::exception& e) {
78442       {
78443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78444       };
78445     } catch (Dali::DaliException e) {
78446       {
78447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78452       };
78453     }
78454   }
78455
78456   jresult = result;
78457   return jresult;
78458 }
78459
78460
78461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78462   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78463   unsigned int arg2 ;
78464   float arg3 ;
78465
78466   arg1 = (Dali::Toolkit::TableView *)jarg1;
78467   arg2 = (unsigned int)jarg2;
78468   arg3 = (float)jarg3;
78469   {
78470     try {
78471       (arg1)->SetRelativeWidth(arg2,arg3);
78472     } catch (std::out_of_range& e) {
78473       {
78474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78475       };
78476     } catch (std::exception& e) {
78477       {
78478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78479       };
78480     } catch (Dali::DaliException e) {
78481       {
78482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78483       };
78484     } catch (...) {
78485       {
78486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78487       };
78488     }
78489   }
78490
78491 }
78492
78493
78494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78495   float jresult ;
78496   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78497   unsigned int arg2 ;
78498   float result;
78499
78500   arg1 = (Dali::Toolkit::TableView *)jarg1;
78501   arg2 = (unsigned int)jarg2;
78502   {
78503     try {
78504       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78505     } catch (std::out_of_range& e) {
78506       {
78507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78508       };
78509     } catch (std::exception& e) {
78510       {
78511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78512       };
78513     } catch (Dali::DaliException e) {
78514       {
78515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78516       };
78517     } catch (...) {
78518       {
78519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78520       };
78521     }
78522   }
78523
78524   jresult = result;
78525   return jresult;
78526 }
78527
78528
78529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78530   unsigned int jresult ;
78531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78532   unsigned int result;
78533
78534   arg1 = (Dali::Toolkit::TableView *)jarg1;
78535   {
78536     try {
78537       result = (unsigned int)(arg1)->GetRows();
78538     } catch (std::out_of_range& e) {
78539       {
78540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78541       };
78542     } catch (std::exception& e) {
78543       {
78544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78545       };
78546     } catch (Dali::DaliException e) {
78547       {
78548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78549       };
78550     } catch (...) {
78551       {
78552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78553       };
78554     }
78555   }
78556
78557   jresult = result;
78558   return jresult;
78559 }
78560
78561
78562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78563   unsigned int jresult ;
78564   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78565   unsigned int result;
78566
78567   arg1 = (Dali::Toolkit::TableView *)jarg1;
78568   {
78569     try {
78570       result = (unsigned int)(arg1)->GetColumns();
78571     } catch (std::out_of_range& e) {
78572       {
78573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78574       };
78575     } catch (std::exception& e) {
78576       {
78577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78578       };
78579     } catch (Dali::DaliException e) {
78580       {
78581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78582       };
78583     } catch (...) {
78584       {
78585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78586       };
78587     }
78588   }
78589
78590   jresult = result;
78591   return jresult;
78592 }
78593
78594
78595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78596   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78597   Dali::Toolkit::TableView::CellPosition arg2 ;
78598   Dali::HorizontalAlignment::Type arg3 ;
78599   Dali::VerticalAlignment::Type arg4 ;
78600   Dali::Toolkit::TableView::CellPosition *argp2 ;
78601
78602   arg1 = (Dali::Toolkit::TableView *)jarg1;
78603   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78604   if (!argp2) {
78605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78606     return ;
78607   }
78608   arg2 = *argp2;
78609   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78610   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78611   {
78612     try {
78613       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78614     } catch (std::out_of_range& e) {
78615       {
78616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78617       };
78618     } catch (std::exception& e) {
78619       {
78620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78621       };
78622     } catch (Dali::DaliException e) {
78623       {
78624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78625       };
78626     } catch (...) {
78627       {
78628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78629       };
78630     }
78631   }
78632
78633 }
78634
78635
78636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78637   unsigned int jresult ;
78638   unsigned int result;
78639
78640   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78641   jresult = result;
78642   return jresult;
78643 }
78644
78645
78646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78647   int jresult ;
78648   int result;
78649
78650   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78651   jresult = (int)result;
78652   return jresult;
78653 }
78654
78655
78656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78657   int jresult ;
78658   int result;
78659
78660   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78661   jresult = (int)result;
78662   return jresult;
78663 }
78664
78665
78666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78667   int jresult ;
78668   int result;
78669
78670   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78671   jresult = (int)result;
78672   return jresult;
78673 }
78674
78675
78676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78677   int jresult ;
78678   int result;
78679
78680   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78681   jresult = (int)result;
78682   return jresult;
78683 }
78684
78685
78686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78687   int jresult ;
78688   int result;
78689
78690   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78691   jresult = (int)result;
78692   return jresult;
78693 }
78694
78695
78696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78697   int jresult ;
78698   int result;
78699
78700   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78701   jresult = (int)result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78707   int jresult ;
78708   int result;
78709
78710   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78711   jresult = (int)result;
78712   return jresult;
78713 }
78714
78715
78716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78717   int jresult ;
78718   int result;
78719
78720   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78721   jresult = (int)result;
78722   return jresult;
78723 }
78724
78725
78726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78727   int jresult ;
78728   int result;
78729
78730   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78731   jresult = (int)result;
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78737   int jresult ;
78738   int result;
78739
78740   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78741   jresult = (int)result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78747   int jresult ;
78748   int result;
78749
78750   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78751   jresult = (int)result;
78752   return jresult;
78753 }
78754
78755
78756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78757   int jresult ;
78758   int result;
78759
78760   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78761   jresult = (int)result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78767   int jresult ;
78768   int result;
78769
78770   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78771   jresult = (int)result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78777   int jresult ;
78778   int result;
78779
78780   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78781   jresult = (int)result;
78782   return jresult;
78783 }
78784
78785
78786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78787   int jresult ;
78788   int result;
78789
78790   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78791   jresult = (int)result;
78792   return jresult;
78793 }
78794
78795
78796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78797   int jresult ;
78798   int result;
78799
78800   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78801   jresult = (int)result;
78802   return jresult;
78803 }
78804
78805
78806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78807   int jresult ;
78808   int result;
78809
78810   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78811   jresult = (int)result;
78812   return jresult;
78813 }
78814
78815
78816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78817   int jresult ;
78818   int result;
78819
78820   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78821   jresult = (int)result;
78822   return jresult;
78823 }
78824
78825
78826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78827   void * jresult ;
78828   Dali::Toolkit::TextLabel::Property *result = 0 ;
78829
78830   {
78831     try {
78832       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78833     } catch (std::out_of_range& e) {
78834       {
78835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78836       };
78837     } catch (std::exception& e) {
78838       {
78839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78840       };
78841     } catch (Dali::DaliException e) {
78842       {
78843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78844       };
78845     } catch (...) {
78846       {
78847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78848       };
78849     }
78850   }
78851
78852   jresult = (void *)result;
78853   return jresult;
78854 }
78855
78856
78857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78858   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78859
78860   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78861   {
78862     try {
78863       delete arg1;
78864     } catch (std::out_of_range& e) {
78865       {
78866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78867       };
78868     } catch (std::exception& e) {
78869       {
78870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78871       };
78872     } catch (Dali::DaliException e) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78875       };
78876     } catch (...) {
78877       {
78878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78879       };
78880     }
78881   }
78882
78883 }
78884
78885
78886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78887   void * jresult ;
78888   Dali::Toolkit::TextLabel result;
78889
78890   {
78891     try {
78892       result = Dali::Toolkit::TextLabel::New();
78893     } catch (std::out_of_range& e) {
78894       {
78895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78896       };
78897     } catch (std::exception& e) {
78898       {
78899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78900       };
78901     } catch (Dali::DaliException e) {
78902       {
78903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78904       };
78905     } catch (...) {
78906       {
78907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78908       };
78909     }
78910   }
78911
78912   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78913   return jresult;
78914 }
78915
78916
78917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78918   void * jresult ;
78919   std::string *arg1 = 0 ;
78920   Dali::Toolkit::TextLabel result;
78921
78922   if (!jarg1) {
78923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78924     return 0;
78925   }
78926   std::string arg1_str(jarg1);
78927   arg1 = &arg1_str;
78928   {
78929     try {
78930       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78931     } catch (std::out_of_range& e) {
78932       {
78933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78934       };
78935     } catch (std::exception& e) {
78936       {
78937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (Dali::DaliException e) {
78940       {
78941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78942       };
78943     } catch (...) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78946       };
78947     }
78948   }
78949
78950   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78951
78952   //argout typemap for const std::string&
78953
78954   return jresult;
78955 }
78956
78957
78958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78959   void * jresult ;
78960   Dali::Toolkit::TextLabel *result = 0 ;
78961
78962   {
78963     try {
78964       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78965     } catch (std::out_of_range& e) {
78966       {
78967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78968       };
78969     } catch (std::exception& e) {
78970       {
78971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78972       };
78973     } catch (Dali::DaliException e) {
78974       {
78975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78976       };
78977     } catch (...) {
78978       {
78979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78980       };
78981     }
78982   }
78983
78984   jresult = (void *)result;
78985   return jresult;
78986 }
78987
78988
78989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78990   void * jresult ;
78991   Dali::Toolkit::TextLabel *arg1 = 0 ;
78992   Dali::Toolkit::TextLabel *result = 0 ;
78993
78994   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78995   if (!arg1) {
78996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78997     return 0;
78998   }
78999   {
79000     try {
79001       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79002     } catch (std::out_of_range& e) {
79003       {
79004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79005       };
79006     } catch (std::exception& e) {
79007       {
79008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79009       };
79010     } catch (Dali::DaliException e) {
79011       {
79012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79013       };
79014     } catch (...) {
79015       {
79016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79017       };
79018     }
79019   }
79020
79021   jresult = (void *)result;
79022   return jresult;
79023 }
79024
79025
79026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79027   void * jresult ;
79028   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79029   Dali::Toolkit::TextLabel *arg2 = 0 ;
79030   Dali::Toolkit::TextLabel *result = 0 ;
79031
79032   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79033   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79034   if (!arg2) {
79035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79036     return 0;
79037   }
79038   {
79039     try {
79040       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79048       };
79049     } catch (Dali::DaliException e) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79052       };
79053     } catch (...) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79056       };
79057     }
79058   }
79059
79060   jresult = (void *)result;
79061   return jresult;
79062 }
79063
79064
79065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79066   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79067
79068   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79069   {
79070     try {
79071       delete arg1;
79072     } catch (std::out_of_range& e) {
79073       {
79074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79075       };
79076     } catch (std::exception& e) {
79077       {
79078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79079       };
79080     } catch (Dali::DaliException e) {
79081       {
79082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79083       };
79084     } catch (...) {
79085       {
79086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79087       };
79088     }
79089   }
79090
79091 }
79092
79093
79094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79095   void * jresult ;
79096   Dali::BaseHandle arg1 ;
79097   Dali::BaseHandle *argp1 ;
79098   Dali::Toolkit::TextLabel result;
79099
79100   argp1 = (Dali::BaseHandle *)jarg1;
79101   if (!argp1) {
79102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79103     return 0;
79104   }
79105   arg1 = *argp1;
79106   {
79107     try {
79108       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79109     } catch (std::out_of_range& e) {
79110       {
79111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (std::exception& e) {
79114       {
79115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79116       };
79117     } catch (Dali::DaliException e) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79120       };
79121     } catch (...) {
79122       {
79123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79124       };
79125     }
79126   }
79127
79128   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79129   return jresult;
79130 }
79131
79132
79133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79134   void * jresult ;
79135   Dali::Toolkit::AccessibilityManager *result = 0 ;
79136
79137   {
79138     try {
79139       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79140     } catch (std::out_of_range& e) {
79141       {
79142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79143       };
79144     } catch (std::exception& e) {
79145       {
79146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79147       };
79148     } catch (Dali::DaliException e) {
79149       {
79150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79151       };
79152     } catch (...) {
79153       {
79154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79155       };
79156     }
79157   }
79158
79159   jresult = (void *)result;
79160   return jresult;
79161 }
79162
79163
79164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79165   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79166
79167   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79168   {
79169     try {
79170       delete arg1;
79171     } catch (std::out_of_range& e) {
79172       {
79173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79174       };
79175     } catch (std::exception& e) {
79176       {
79177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79178       };
79179     } catch (Dali::DaliException e) {
79180       {
79181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79182       };
79183     } catch (...) {
79184       {
79185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79186       };
79187     }
79188   }
79189
79190 }
79191
79192
79193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79194   void * jresult ;
79195   Dali::Toolkit::AccessibilityManager result;
79196
79197   {
79198     try {
79199       result = Dali::Toolkit::AccessibilityManager::Get();
79200     } catch (std::out_of_range& e) {
79201       {
79202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (std::exception& e) {
79205       {
79206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79207       };
79208     } catch (Dali::DaliException e) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79211       };
79212     } catch (...) {
79213       {
79214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79215       };
79216     }
79217   }
79218
79219   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79220   return jresult;
79221 }
79222
79223
79224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79226   Dali::Actor arg2 ;
79227   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79228   std::string *arg4 = 0 ;
79229   Dali::Actor *argp2 ;
79230
79231   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79232   argp2 = (Dali::Actor *)jarg2;
79233   if (!argp2) {
79234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79235     return ;
79236   }
79237   arg2 = *argp2;
79238   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79239   if (!jarg4) {
79240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79241     return ;
79242   }
79243   std::string arg4_str(jarg4);
79244   arg4 = &arg4_str;
79245   {
79246     try {
79247       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79248     } catch (std::out_of_range& e) {
79249       {
79250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79251       };
79252     } catch (std::exception& e) {
79253       {
79254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79255       };
79256     } catch (Dali::DaliException e) {
79257       {
79258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79259       };
79260     } catch (...) {
79261       {
79262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79263       };
79264     }
79265   }
79266
79267
79268   //argout typemap for const std::string&
79269
79270 }
79271
79272
79273 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79274   char * jresult ;
79275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79276   Dali::Actor arg2 ;
79277   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79278   Dali::Actor *argp2 ;
79279   std::string result;
79280
79281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79282   argp2 = (Dali::Actor *)jarg2;
79283   if (!argp2) {
79284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79285     return 0;
79286   }
79287   arg2 = *argp2;
79288   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79289   {
79290     try {
79291       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79292     } catch (std::out_of_range& e) {
79293       {
79294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79295       };
79296     } catch (std::exception& e) {
79297       {
79298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79299       };
79300     } catch (Dali::DaliException e) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79303       };
79304     } catch (...) {
79305       {
79306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79307       };
79308     }
79309   }
79310
79311   jresult = SWIG_csharp_string_callback((&result)->c_str());
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79318   Dali::Actor arg2 ;
79319   unsigned int arg3 ;
79320   Dali::Actor *argp2 ;
79321
79322   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79323   argp2 = (Dali::Actor *)jarg2;
79324   if (!argp2) {
79325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79326     return ;
79327   }
79328   arg2 = *argp2;
79329   arg3 = (unsigned int)jarg3;
79330   {
79331     try {
79332       (arg1)->SetFocusOrder(arg2,arg3);
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79340       };
79341     } catch (Dali::DaliException e) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79344       };
79345     } catch (...) {
79346       {
79347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79348       };
79349     }
79350   }
79351
79352 }
79353
79354
79355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79356   unsigned int jresult ;
79357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79358   Dali::Actor arg2 ;
79359   Dali::Actor *argp2 ;
79360   unsigned int result;
79361
79362   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79363   argp2 = (Dali::Actor *)jarg2;
79364   if (!argp2) {
79365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79366     return 0;
79367   }
79368   arg2 = *argp2;
79369   {
79370     try {
79371       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79372     } catch (std::out_of_range& e) {
79373       {
79374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79375       };
79376     } catch (std::exception& e) {
79377       {
79378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79379       };
79380     } catch (Dali::DaliException e) {
79381       {
79382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79383       };
79384     } catch (...) {
79385       {
79386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79387       };
79388     }
79389   }
79390
79391   jresult = result;
79392   return jresult;
79393 }
79394
79395
79396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79397   unsigned int jresult ;
79398   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79399   unsigned int result;
79400
79401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79402   {
79403     try {
79404       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79405     } catch (std::out_of_range& e) {
79406       {
79407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79408       };
79409     } catch (std::exception& e) {
79410       {
79411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79412       };
79413     } catch (Dali::DaliException e) {
79414       {
79415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79416       };
79417     } catch (...) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79420       };
79421     }
79422   }
79423
79424   jresult = result;
79425   return jresult;
79426 }
79427
79428
79429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79430   void * jresult ;
79431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79432   unsigned int arg2 ;
79433   Dali::Actor result;
79434
79435   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79436   arg2 = (unsigned int)jarg2;
79437   {
79438     try {
79439       result = (arg1)->GetActorByFocusOrder(arg2);
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 = new Dali::Actor((const Dali::Actor &)result);
79460   return jresult;
79461 }
79462
79463
79464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79465   unsigned int jresult ;
79466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79467   Dali::Actor arg2 ;
79468   Dali::Actor *argp2 ;
79469   bool result;
79470
79471   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79472   argp2 = (Dali::Actor *)jarg2;
79473   if (!argp2) {
79474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79475     return 0;
79476   }
79477   arg2 = *argp2;
79478   {
79479     try {
79480       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79481     } catch (std::out_of_range& e) {
79482       {
79483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79484       };
79485     } catch (std::exception& e) {
79486       {
79487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79488       };
79489     } catch (Dali::DaliException e) {
79490       {
79491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79492       };
79493     } catch (...) {
79494       {
79495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79496       };
79497     }
79498   }
79499
79500   jresult = result;
79501   return jresult;
79502 }
79503
79504
79505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79506   void * jresult ;
79507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79508   Dali::Actor result;
79509
79510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79511   {
79512     try {
79513       result = (arg1)->GetCurrentFocusActor();
79514     } catch (std::out_of_range& e) {
79515       {
79516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79517       };
79518     } catch (std::exception& e) {
79519       {
79520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79521       };
79522     } catch (Dali::DaliException e) {
79523       {
79524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79525       };
79526     } catch (...) {
79527       {
79528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79529       };
79530     }
79531   }
79532
79533   jresult = new Dali::Actor((const Dali::Actor &)result);
79534   return jresult;
79535 }
79536
79537
79538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79539   void * jresult ;
79540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79541   Dali::Actor result;
79542
79543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79544   {
79545     try {
79546       result = (arg1)->GetCurrentFocusGroup();
79547     } catch (std::out_of_range& e) {
79548       {
79549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79550       };
79551     } catch (std::exception& e) {
79552       {
79553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79554       };
79555     } catch (Dali::DaliException e) {
79556       {
79557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79558       };
79559     } catch (...) {
79560       {
79561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79562       };
79563     }
79564   }
79565
79566   jresult = new Dali::Actor((const Dali::Actor &)result);
79567   return jresult;
79568 }
79569
79570
79571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79572   unsigned int jresult ;
79573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79574   unsigned int result;
79575
79576   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79577   {
79578     try {
79579       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79580     } catch (std::out_of_range& e) {
79581       {
79582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79583       };
79584     } catch (std::exception& e) {
79585       {
79586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79587       };
79588     } catch (Dali::DaliException e) {
79589       {
79590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79591       };
79592     } catch (...) {
79593       {
79594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79595       };
79596     }
79597   }
79598
79599   jresult = result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79605   unsigned int jresult ;
79606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79607   bool result;
79608
79609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79610   {
79611     try {
79612       result = (bool)(arg1)->MoveFocusForward();
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (Dali::DaliException e) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79624       };
79625     } catch (...) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79628       };
79629     }
79630   }
79631
79632   jresult = result;
79633   return jresult;
79634 }
79635
79636
79637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79638   unsigned int jresult ;
79639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79640   bool result;
79641
79642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79643   {
79644     try {
79645       result = (bool)(arg1)->MoveFocusBackward();
79646     } catch (std::out_of_range& e) {
79647       {
79648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79649       };
79650     } catch (std::exception& e) {
79651       {
79652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79653       };
79654     } catch (Dali::DaliException e) {
79655       {
79656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79657       };
79658     } catch (...) {
79659       {
79660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79661       };
79662     }
79663   }
79664
79665   jresult = result;
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79672
79673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79674   {
79675     try {
79676       (arg1)->ClearFocus();
79677     } catch (std::out_of_range& e) {
79678       {
79679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79680       };
79681     } catch (std::exception& e) {
79682       {
79683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79684       };
79685     } catch (Dali::DaliException e) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79688       };
79689     } catch (...) {
79690       {
79691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79692       };
79693     }
79694   }
79695
79696 }
79697
79698
79699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79701
79702   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79703   {
79704     try {
79705       (arg1)->Reset();
79706     } catch (std::out_of_range& e) {
79707       {
79708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79709       };
79710     } catch (std::exception& e) {
79711       {
79712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79713       };
79714     } catch (Dali::DaliException e) {
79715       {
79716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79717       };
79718     } catch (...) {
79719       {
79720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79721       };
79722     }
79723   }
79724
79725 }
79726
79727
79728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79729   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79730   Dali::Actor arg2 ;
79731   bool arg3 ;
79732   Dali::Actor *argp2 ;
79733
79734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79735   argp2 = (Dali::Actor *)jarg2;
79736   if (!argp2) {
79737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79738     return ;
79739   }
79740   arg2 = *argp2;
79741   arg3 = jarg3 ? true : false;
79742   {
79743     try {
79744       (arg1)->SetFocusGroup(arg2,arg3);
79745     } catch (std::out_of_range& e) {
79746       {
79747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79748       };
79749     } catch (std::exception& e) {
79750       {
79751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79752       };
79753     } catch (Dali::DaliException e) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79756       };
79757     } catch (...) {
79758       {
79759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79760       };
79761     }
79762   }
79763
79764 }
79765
79766
79767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79768   unsigned int jresult ;
79769   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79770   Dali::Actor arg2 ;
79771   Dali::Actor *argp2 ;
79772   bool result;
79773
79774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79775   argp2 = (Dali::Actor *)jarg2;
79776   if (!argp2) {
79777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79778     return 0;
79779   }
79780   arg2 = *argp2;
79781   {
79782     try {
79783       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79784     } catch (std::out_of_range& e) {
79785       {
79786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79787       };
79788     } catch (std::exception& e) {
79789       {
79790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79791       };
79792     } catch (Dali::DaliException e) {
79793       {
79794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79795       };
79796     } catch (...) {
79797       {
79798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79799       };
79800     }
79801   }
79802
79803   jresult = result;
79804   return jresult;
79805 }
79806
79807
79808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79809   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79810   bool arg2 ;
79811
79812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79813   arg2 = jarg2 ? true : false;
79814   {
79815     try {
79816       (arg1)->SetGroupMode(arg2);
79817     } catch (std::out_of_range& e) {
79818       {
79819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79820       };
79821     } catch (std::exception& e) {
79822       {
79823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79824       };
79825     } catch (Dali::DaliException e) {
79826       {
79827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79828       };
79829     } catch (...) {
79830       {
79831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79832       };
79833     }
79834   }
79835
79836 }
79837
79838
79839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79840   unsigned int jresult ;
79841   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79842   bool result;
79843
79844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79845   {
79846     try {
79847       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79848     } catch (std::out_of_range& e) {
79849       {
79850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79851       };
79852     } catch (std::exception& e) {
79853       {
79854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79855       };
79856     } catch (Dali::DaliException e) {
79857       {
79858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79859       };
79860     } catch (...) {
79861       {
79862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79863       };
79864     }
79865   }
79866
79867   jresult = result;
79868   return jresult;
79869 }
79870
79871
79872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79873   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79874   bool arg2 ;
79875
79876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79877   arg2 = jarg2 ? true : false;
79878   {
79879     try {
79880       (arg1)->SetWrapMode(arg2);
79881     } catch (std::out_of_range& e) {
79882       {
79883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79884       };
79885     } catch (std::exception& e) {
79886       {
79887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79888       };
79889     } catch (Dali::DaliException e) {
79890       {
79891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79892       };
79893     } catch (...) {
79894       {
79895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79896       };
79897     }
79898   }
79899
79900 }
79901
79902
79903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79904   unsigned int jresult ;
79905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79906   bool result;
79907
79908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79909   {
79910     try {
79911       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79912     } catch (std::out_of_range& e) {
79913       {
79914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79915       };
79916     } catch (std::exception& e) {
79917       {
79918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79919       };
79920     } catch (Dali::DaliException e) {
79921       {
79922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79923       };
79924     } catch (...) {
79925       {
79926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79927       };
79928     }
79929   }
79930
79931   jresult = result;
79932   return jresult;
79933 }
79934
79935
79936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79938   Dali::Actor arg2 ;
79939   Dali::Actor *argp2 ;
79940
79941   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79942   argp2 = (Dali::Actor *)jarg2;
79943   if (!argp2) {
79944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79945     return ;
79946   }
79947   arg2 = *argp2;
79948   {
79949     try {
79950       (arg1)->SetFocusIndicatorActor(arg2);
79951     } catch (std::out_of_range& e) {
79952       {
79953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79954       };
79955     } catch (std::exception& e) {
79956       {
79957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79958       };
79959     } catch (Dali::DaliException e) {
79960       {
79961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79962       };
79963     } catch (...) {
79964       {
79965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79966       };
79967     }
79968   }
79969
79970 }
79971
79972
79973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79974   void * jresult ;
79975   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79976   Dali::Actor result;
79977
79978   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79979   {
79980     try {
79981       result = (arg1)->GetFocusIndicatorActor();
79982     } catch (std::out_of_range& e) {
79983       {
79984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79985       };
79986     } catch (std::exception& e) {
79987       {
79988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79989       };
79990     } catch (Dali::DaliException e) {
79991       {
79992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79993       };
79994     } catch (...) {
79995       {
79996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79997       };
79998     }
79999   }
80000
80001   jresult = new Dali::Actor((const Dali::Actor &)result);
80002   return jresult;
80003 }
80004
80005
80006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80007   void * jresult ;
80008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80009   Dali::Actor arg2 ;
80010   Dali::Actor *argp2 ;
80011   Dali::Actor result;
80012
80013   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80014   argp2 = (Dali::Actor *)jarg2;
80015   if (!argp2) {
80016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80017     return 0;
80018   }
80019   arg2 = *argp2;
80020   {
80021     try {
80022       result = (arg1)->GetFocusGroup(arg2);
80023     } catch (std::out_of_range& e) {
80024       {
80025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80026       };
80027     } catch (std::exception& e) {
80028       {
80029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80030       };
80031     } catch (Dali::DaliException e) {
80032       {
80033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80034       };
80035     } catch (...) {
80036       {
80037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80038       };
80039     }
80040   }
80041
80042   jresult = new Dali::Actor((const Dali::Actor &)result);
80043   return jresult;
80044 }
80045
80046
80047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80048   void * jresult ;
80049   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80050   Dali::Vector2 result;
80051
80052   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80053   {
80054     try {
80055       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80056     } catch (std::out_of_range& e) {
80057       {
80058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80059       };
80060     } catch (std::exception& e) {
80061       {
80062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80063       };
80064     } catch (Dali::DaliException e) {
80065       {
80066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80067       };
80068     } catch (...) {
80069       {
80070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80071       };
80072     }
80073   }
80074
80075   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80081   void * jresult ;
80082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80083   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80084
80085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80086   {
80087     try {
80088       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80089     } catch (std::out_of_range& e) {
80090       {
80091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80092       };
80093     } catch (std::exception& e) {
80094       {
80095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80096       };
80097     } catch (Dali::DaliException e) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80100       };
80101     } catch (...) {
80102       {
80103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80104       };
80105     }
80106   }
80107
80108   jresult = (void *)result;
80109   return jresult;
80110 }
80111
80112
80113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80114   void * jresult ;
80115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80116   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80117
80118   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80119   {
80120     try {
80121       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80122     } catch (std::out_of_range& e) {
80123       {
80124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80125       };
80126     } catch (std::exception& e) {
80127       {
80128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80129       };
80130     } catch (Dali::DaliException e) {
80131       {
80132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80133       };
80134     } catch (...) {
80135       {
80136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80137       };
80138     }
80139   }
80140
80141   jresult = (void *)result;
80142   return jresult;
80143 }
80144
80145
80146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80147   void * jresult ;
80148   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80149   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80150
80151   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80152   {
80153     try {
80154       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80155     } catch (std::out_of_range& e) {
80156       {
80157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80158       };
80159     } catch (std::exception& e) {
80160       {
80161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80162       };
80163     } catch (Dali::DaliException e) {
80164       {
80165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80166       };
80167     } catch (...) {
80168       {
80169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80170       };
80171     }
80172   }
80173
80174   jresult = (void *)result;
80175   return jresult;
80176 }
80177
80178
80179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80180   void * jresult ;
80181   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80182   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80183
80184   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80185   {
80186     try {
80187       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80188     } catch (std::out_of_range& e) {
80189       {
80190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80191       };
80192     } catch (std::exception& e) {
80193       {
80194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80195       };
80196     } catch (Dali::DaliException e) {
80197       {
80198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80199       };
80200     } catch (...) {
80201       {
80202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80203       };
80204     }
80205   }
80206
80207   jresult = (void *)result;
80208   return jresult;
80209 }
80210
80211
80212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80213   void * jresult ;
80214   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80215   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80216
80217   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80218   {
80219     try {
80220       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80221     } catch (std::out_of_range& e) {
80222       {
80223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80224       };
80225     } catch (std::exception& e) {
80226       {
80227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80228       };
80229     } catch (Dali::DaliException e) {
80230       {
80231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80232       };
80233     } catch (...) {
80234       {
80235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80236       };
80237     }
80238   }
80239
80240   jresult = (void *)result;
80241   return jresult;
80242 }
80243
80244
80245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80246   void * jresult ;
80247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80248   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80249
80250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80251   {
80252     try {
80253       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80254     } catch (std::out_of_range& e) {
80255       {
80256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80257       };
80258     } catch (std::exception& e) {
80259       {
80260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80261       };
80262     } catch (Dali::DaliException e) {
80263       {
80264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80265       };
80266     } catch (...) {
80267       {
80268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80269       };
80270     }
80271   }
80272
80273   jresult = (void *)result;
80274   return jresult;
80275 }
80276
80277
80278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80279   void * jresult ;
80280   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80281   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80282
80283   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80284   {
80285     try {
80286       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80287     } catch (std::out_of_range& e) {
80288       {
80289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80290       };
80291     } catch (std::exception& e) {
80292       {
80293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80294       };
80295     } catch (Dali::DaliException e) {
80296       {
80297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80298       };
80299     } catch (...) {
80300       {
80301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80302       };
80303     }
80304   }
80305
80306   jresult = (void *)result;
80307   return jresult;
80308 }
80309
80310
80311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80312   void * jresult ;
80313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80314   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80315
80316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80317   {
80318     try {
80319       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80320     } catch (std::out_of_range& e) {
80321       {
80322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80323       };
80324     } catch (std::exception& e) {
80325       {
80326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80327       };
80328     } catch (Dali::DaliException e) {
80329       {
80330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80331       };
80332     } catch (...) {
80333       {
80334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80335       };
80336     }
80337   }
80338
80339   jresult = (void *)result;
80340   return jresult;
80341 }
80342
80343
80344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80345   void * jresult ;
80346   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80347   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80348
80349   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80350   {
80351     try {
80352       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80353     } catch (std::out_of_range& e) {
80354       {
80355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80356       };
80357     } catch (std::exception& e) {
80358       {
80359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80360       };
80361     } catch (Dali::DaliException e) {
80362       {
80363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80364       };
80365     } catch (...) {
80366       {
80367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80368       };
80369     }
80370   }
80371
80372   jresult = (void *)result;
80373   return jresult;
80374 }
80375
80376
80377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80378   void * jresult ;
80379   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80380   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80381
80382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80383   {
80384     try {
80385       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80386     } catch (std::out_of_range& e) {
80387       {
80388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80389       };
80390     } catch (std::exception& e) {
80391       {
80392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80393       };
80394     } catch (Dali::DaliException e) {
80395       {
80396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80397       };
80398     } catch (...) {
80399       {
80400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80401       };
80402     }
80403   }
80404
80405   jresult = (void *)result;
80406   return jresult;
80407 }
80408
80409
80410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80411   void * jresult ;
80412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80413   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80414
80415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80416   {
80417     try {
80418       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80419     } catch (std::out_of_range& e) {
80420       {
80421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80422       };
80423     } catch (std::exception& e) {
80424       {
80425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80426       };
80427     } catch (Dali::DaliException e) {
80428       {
80429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80430       };
80431     } catch (...) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80434       };
80435     }
80436   }
80437
80438   jresult = (void *)result;
80439   return jresult;
80440 }
80441
80442
80443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80444   void * jresult ;
80445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80446   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80447
80448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80449   {
80450     try {
80451       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (Dali::DaliException e) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80463       };
80464     } catch (...) {
80465       {
80466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80467       };
80468     }
80469   }
80470
80471   jresult = (void *)result;
80472   return jresult;
80473 }
80474
80475
80476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80477   void * jresult ;
80478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80479   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80480
80481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80482   {
80483     try {
80484       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80485     } catch (std::out_of_range& e) {
80486       {
80487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80488       };
80489     } catch (std::exception& e) {
80490       {
80491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80492       };
80493     } catch (Dali::DaliException e) {
80494       {
80495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80496       };
80497     } catch (...) {
80498       {
80499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80500       };
80501     }
80502   }
80503
80504   jresult = (void *)result;
80505   return jresult;
80506 }
80507
80508
80509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80510   void * jresult ;
80511   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80512   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80513
80514   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80515   {
80516     try {
80517       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80518     } catch (std::out_of_range& e) {
80519       {
80520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80521       };
80522     } catch (std::exception& e) {
80523       {
80524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80525       };
80526     } catch (Dali::DaliException e) {
80527       {
80528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80529       };
80530     } catch (...) {
80531       {
80532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80533       };
80534     }
80535   }
80536
80537   jresult = (void *)result;
80538   return jresult;
80539 }
80540
80541
80542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80543   void * jresult ;
80544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80545   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80546
80547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80548   {
80549     try {
80550       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80551     } catch (std::out_of_range& e) {
80552       {
80553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80554       };
80555     } catch (std::exception& e) {
80556       {
80557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80558       };
80559     } catch (Dali::DaliException e) {
80560       {
80561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80562       };
80563     } catch (...) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80566       };
80567     }
80568   }
80569
80570   jresult = (void *)result;
80571   return jresult;
80572 }
80573
80574
80575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80576   void * jresult ;
80577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80578   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80579
80580   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80581   {
80582     try {
80583       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80584     } catch (std::out_of_range& e) {
80585       {
80586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80587       };
80588     } catch (std::exception& e) {
80589       {
80590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80591       };
80592     } catch (Dali::DaliException e) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80595       };
80596     } catch (...) {
80597       {
80598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80599       };
80600     }
80601   }
80602
80603   jresult = (void *)result;
80604   return jresult;
80605 }
80606
80607
80608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80609   void * jresult ;
80610   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80611   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80612
80613   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80614   {
80615     try {
80616       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80617     } catch (std::out_of_range& e) {
80618       {
80619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80620       };
80621     } catch (std::exception& e) {
80622       {
80623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80624       };
80625     } catch (Dali::DaliException e) {
80626       {
80627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80628       };
80629     } catch (...) {
80630       {
80631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80632       };
80633     }
80634   }
80635
80636   jresult = (void *)result;
80637   return jresult;
80638 }
80639
80640
80641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80642   void * jresult ;
80643   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80644   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80645
80646   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80647   {
80648     try {
80649       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80650     } catch (std::out_of_range& e) {
80651       {
80652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80653       };
80654     } catch (std::exception& e) {
80655       {
80656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80657       };
80658     } catch (Dali::DaliException e) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80661       };
80662     } catch (...) {
80663       {
80664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80665       };
80666     }
80667   }
80668
80669   jresult = (void *)result;
80670   return jresult;
80671 }
80672
80673
80674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80675   void * jresult ;
80676   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80677   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80678
80679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80680   {
80681     try {
80682       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80683     } catch (std::out_of_range& e) {
80684       {
80685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80686       };
80687     } catch (std::exception& e) {
80688       {
80689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80690       };
80691     } catch (Dali::DaliException e) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80694       };
80695     } catch (...) {
80696       {
80697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80698       };
80699     }
80700   }
80701
80702   jresult = (void *)result;
80703   return jresult;
80704 }
80705
80706
80707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80708   void * jresult ;
80709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80710   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80711
80712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80713   {
80714     try {
80715       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (Dali::DaliException e) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80727       };
80728     } catch (...) {
80729       {
80730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80731       };
80732     }
80733   }
80734
80735   jresult = (void *)result;
80736   return jresult;
80737 }
80738
80739
80740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80741   void * jresult ;
80742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80744
80745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80746   {
80747     try {
80748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80749     } catch (std::out_of_range& e) {
80750       {
80751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80752       };
80753     } catch (std::exception& e) {
80754       {
80755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80756       };
80757     } catch (Dali::DaliException e) {
80758       {
80759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80760       };
80761     } catch (...) {
80762       {
80763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80764       };
80765     }
80766   }
80767
80768   jresult = (void *)result;
80769   return jresult;
80770 }
80771
80772
80773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80774   void * jresult ;
80775   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80776   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80777
80778   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80779   {
80780     try {
80781       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80782     } catch (std::out_of_range& e) {
80783       {
80784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80785       };
80786     } catch (std::exception& e) {
80787       {
80788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80789       };
80790     } catch (Dali::DaliException e) {
80791       {
80792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80793       };
80794     } catch (...) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80797       };
80798     }
80799   }
80800
80801   jresult = (void *)result;
80802   return jresult;
80803 }
80804
80805
80806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80807   void * jresult ;
80808   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80809   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80810
80811   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80812   {
80813     try {
80814       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80815     } catch (std::out_of_range& e) {
80816       {
80817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80818       };
80819     } catch (std::exception& e) {
80820       {
80821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80822       };
80823     } catch (Dali::DaliException e) {
80824       {
80825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80826       };
80827     } catch (...) {
80828       {
80829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80830       };
80831     }
80832   }
80833
80834   jresult = (void *)result;
80835   return jresult;
80836 }
80837
80838
80839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80840   void * jresult ;
80841   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80842   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80843
80844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80845   {
80846     try {
80847       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80848     } catch (std::out_of_range& e) {
80849       {
80850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80851       };
80852     } catch (std::exception& e) {
80853       {
80854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80855       };
80856     } catch (Dali::DaliException e) {
80857       {
80858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80859       };
80860     } catch (...) {
80861       {
80862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80863       };
80864     }
80865   }
80866
80867   jresult = (void *)result;
80868   return jresult;
80869 }
80870
80871
80872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80873   void * jresult ;
80874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80876
80877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80878   {
80879     try {
80880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80888       };
80889     } catch (Dali::DaliException e) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80892       };
80893     } catch (...) {
80894       {
80895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80896       };
80897     }
80898   }
80899
80900   jresult = (void *)result;
80901   return jresult;
80902 }
80903
80904
80905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80906   void * jresult ;
80907   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80908   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80909
80910   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80911   {
80912     try {
80913       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80914     } catch (std::out_of_range& e) {
80915       {
80916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80917       };
80918     } catch (std::exception& e) {
80919       {
80920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80921       };
80922     } catch (Dali::DaliException e) {
80923       {
80924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80925       };
80926     } catch (...) {
80927       {
80928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80929       };
80930     }
80931   }
80932
80933   jresult = (void *)result;
80934   return jresult;
80935 }
80936
80937
80938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80939   void * jresult ;
80940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80941   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80942
80943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80944   {
80945     try {
80946       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80947     } catch (std::out_of_range& e) {
80948       {
80949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (std::exception& e) {
80952       {
80953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80954       };
80955     } catch (Dali::DaliException e) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80958       };
80959     } catch (...) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80962       };
80963     }
80964   }
80965
80966   jresult = (void *)result;
80967   return jresult;
80968 }
80969
80970
80971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80972   void * jresult ;
80973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80974   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80975
80976   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80977   {
80978     try {
80979       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80980     } catch (std::out_of_range& e) {
80981       {
80982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80983       };
80984     } catch (std::exception& e) {
80985       {
80986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80987       };
80988     } catch (Dali::DaliException e) {
80989       {
80990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80991       };
80992     } catch (...) {
80993       {
80994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80995       };
80996     }
80997   }
80998
80999   jresult = (void *)result;
81000   return jresult;
81001 }
81002
81003
81004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81005   void * jresult ;
81006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81007   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81008
81009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81010   {
81011     try {
81012       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81013     } catch (std::out_of_range& e) {
81014       {
81015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81016       };
81017     } catch (std::exception& e) {
81018       {
81019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81020       };
81021     } catch (Dali::DaliException e) {
81022       {
81023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81024       };
81025     } catch (...) {
81026       {
81027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81028       };
81029     }
81030   }
81031
81032   jresult = (void *)result;
81033   return jresult;
81034 }
81035
81036
81037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81038   void * jresult ;
81039   Dali::Toolkit::StyleManager *result = 0 ;
81040
81041   {
81042     try {
81043       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81044     } catch (std::out_of_range& e) {
81045       {
81046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81047       };
81048     } catch (std::exception& e) {
81049       {
81050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81051       };
81052     } catch (Dali::DaliException e) {
81053       {
81054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81055       };
81056     } catch (...) {
81057       {
81058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81059       };
81060     }
81061   }
81062
81063   jresult = (void *)result;
81064   return jresult;
81065 }
81066
81067
81068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81069   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81070
81071   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81072   {
81073     try {
81074       delete arg1;
81075     } catch (std::out_of_range& e) {
81076       {
81077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81078       };
81079     } catch (std::exception& e) {
81080       {
81081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81082       };
81083     } catch (Dali::DaliException e) {
81084       {
81085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81086       };
81087     } catch (...) {
81088       {
81089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81090       };
81091     }
81092   }
81093
81094 }
81095
81096
81097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81098   void * jresult ;
81099   Dali::Toolkit::StyleManager result;
81100
81101   {
81102     try {
81103       result = Dali::Toolkit::StyleManager::Get();
81104     } catch (std::out_of_range& e) {
81105       {
81106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81107       };
81108     } catch (std::exception& e) {
81109       {
81110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81111       };
81112     } catch (Dali::DaliException e) {
81113       {
81114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81115       };
81116     } catch (...) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81119       };
81120     }
81121   }
81122
81123   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81124   return jresult;
81125 }
81126
81127
81128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81129   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81130   std::string *arg2 = 0 ;
81131
81132   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81133   if (!jarg2) {
81134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81135     return ;
81136   }
81137   std::string arg2_str(jarg2);
81138   arg2 = &arg2_str;
81139   {
81140     try {
81141       (arg1)->ApplyTheme((std::string const &)*arg2);
81142     } catch (std::out_of_range& e) {
81143       {
81144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81145       };
81146     } catch (std::exception& e) {
81147       {
81148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81149       };
81150     } catch (Dali::DaliException e) {
81151       {
81152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81153       };
81154     } catch (...) {
81155       {
81156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81157       };
81158     }
81159   }
81160
81161
81162   //argout typemap for const std::string&
81163
81164 }
81165
81166
81167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81168   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81169
81170   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81171   {
81172     try {
81173       (arg1)->ApplyDefaultTheme();
81174     } catch (std::out_of_range& e) {
81175       {
81176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81177       };
81178     } catch (std::exception& e) {
81179       {
81180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81181       };
81182     } catch (Dali::DaliException e) {
81183       {
81184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81185       };
81186     } catch (...) {
81187       {
81188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81189       };
81190     }
81191   }
81192
81193 }
81194
81195
81196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81197   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81198   std::string *arg2 = 0 ;
81199   Dali::Property::Value *arg3 = 0 ;
81200
81201   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81202   if (!jarg2) {
81203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81204     return ;
81205   }
81206   std::string arg2_str(jarg2);
81207   arg2 = &arg2_str;
81208   arg3 = (Dali::Property::Value *)jarg3;
81209   if (!arg3) {
81210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81211     return ;
81212   }
81213   {
81214     try {
81215       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81216     } catch (std::out_of_range& e) {
81217       {
81218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81219       };
81220     } catch (std::exception& e) {
81221       {
81222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81223       };
81224     } catch (Dali::DaliException e) {
81225       {
81226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81227       };
81228     } catch (...) {
81229       {
81230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81231       };
81232     }
81233   }
81234
81235
81236   //argout typemap for const std::string&
81237
81238 }
81239
81240
81241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81242   unsigned int jresult ;
81243   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81244   std::string *arg2 = 0 ;
81245   Dali::Property::Value *arg3 = 0 ;
81246   bool result;
81247
81248   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81249   if (!jarg2) {
81250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81251     return 0;
81252   }
81253   std::string arg2_str(jarg2);
81254   arg2 = &arg2_str;
81255   arg3 = (Dali::Property::Value *)jarg3;
81256   if (!arg3) {
81257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81258     return 0;
81259   }
81260   {
81261     try {
81262       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81263     } catch (std::out_of_range& e) {
81264       {
81265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81266       };
81267     } catch (std::exception& e) {
81268       {
81269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (Dali::DaliException e) {
81272       {
81273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81274       };
81275     } catch (...) {
81276       {
81277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81278       };
81279     }
81280   }
81281
81282   jresult = result;
81283
81284   //argout typemap for const std::string&
81285
81286   return jresult;
81287 }
81288
81289
81290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81291   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81292   Dali::Toolkit::Control arg2 ;
81293   std::string *arg3 = 0 ;
81294   std::string *arg4 = 0 ;
81295   Dali::Toolkit::Control *argp2 ;
81296
81297   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81298   argp2 = (Dali::Toolkit::Control *)jarg2;
81299   if (!argp2) {
81300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81301     return ;
81302   }
81303   arg2 = *argp2;
81304   if (!jarg3) {
81305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81306     return ;
81307   }
81308   std::string arg3_str(jarg3);
81309   arg3 = &arg3_str;
81310   if (!jarg4) {
81311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81312     return ;
81313   }
81314   std::string arg4_str(jarg4);
81315   arg4 = &arg4_str;
81316   {
81317     try {
81318       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81319     } catch (std::out_of_range& e) {
81320       {
81321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81322       };
81323     } catch (std::exception& e) {
81324       {
81325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81326       };
81327     } catch (Dali::DaliException e) {
81328       {
81329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81330       };
81331     } catch (...) {
81332       {
81333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81334       };
81335     }
81336   }
81337
81338
81339   //argout typemap for const std::string&
81340
81341
81342   //argout typemap for const std::string&
81343
81344 }
81345
81346
81347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81348   void * jresult ;
81349   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81350   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81351
81352   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81353   {
81354     try {
81355       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
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 = (void *)result;
81376   return jresult;
81377 }
81378
81379
81380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81381   int jresult ;
81382   int result;
81383
81384   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81385   jresult = (int)result;
81386   return jresult;
81387 }
81388
81389
81390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81391   int jresult ;
81392   int result;
81393
81394   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81395   jresult = (int)result;
81396   return jresult;
81397 }
81398
81399
81400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81401   int jresult ;
81402   int result;
81403
81404   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81405   jresult = (int)result;
81406   return jresult;
81407 }
81408
81409
81410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81411   int jresult ;
81412   int result;
81413
81414   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81415   jresult = (int)result;
81416   return jresult;
81417 }
81418
81419
81420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81421   int jresult ;
81422   int result;
81423
81424   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81425   jresult = (int)result;
81426   return jresult;
81427 }
81428
81429
81430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81431   int jresult ;
81432   int result;
81433
81434   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81435   jresult = (int)result;
81436   return jresult;
81437 }
81438
81439
81440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81441   int jresult ;
81442   int result;
81443
81444   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81445   jresult = (int)result;
81446   return jresult;
81447 }
81448
81449
81450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81451   int jresult ;
81452   int result;
81453
81454   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81455   jresult = (int)result;
81456   return jresult;
81457 }
81458
81459
81460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81461   int jresult ;
81462   int result;
81463
81464   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81465   jresult = (int)result;
81466   return jresult;
81467 }
81468
81469
81470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81471   int jresult ;
81472   int result;
81473
81474   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81475   jresult = (int)result;
81476   return jresult;
81477 }
81478
81479
81480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81481   int jresult ;
81482   int result;
81483
81484   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81485   jresult = (int)result;
81486   return jresult;
81487 }
81488
81489
81490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81491   int jresult ;
81492   int result;
81493
81494   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81495   jresult = (int)result;
81496   return jresult;
81497 }
81498
81499
81500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81501   int jresult ;
81502   int result;
81503
81504   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81505   jresult = (int)result;
81506   return jresult;
81507 }
81508
81509
81510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81511   int jresult ;
81512   int result;
81513
81514   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81515   jresult = (int)result;
81516   return jresult;
81517 }
81518
81519
81520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81521   int jresult ;
81522   int result;
81523
81524   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81525   jresult = (int)result;
81526   return jresult;
81527 }
81528
81529
81530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81531   void * jresult ;
81532   Dali::Toolkit::Slider::Property *result = 0 ;
81533
81534   {
81535     try {
81536       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81537     } catch (std::out_of_range& e) {
81538       {
81539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81540       };
81541     } catch (std::exception& e) {
81542       {
81543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81544       };
81545     } catch (Dali::DaliException e) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81548       };
81549     } catch (...) {
81550       {
81551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81552       };
81553     }
81554   }
81555
81556   jresult = (void *)result;
81557   return jresult;
81558 }
81559
81560
81561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81562   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81563
81564   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81565   {
81566     try {
81567       delete arg1;
81568     } catch (std::out_of_range& e) {
81569       {
81570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81571       };
81572     } catch (std::exception& e) {
81573       {
81574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81575       };
81576     } catch (Dali::DaliException e) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81579       };
81580     } catch (...) {
81581       {
81582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81583       };
81584     }
81585   }
81586
81587 }
81588
81589
81590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81591   void * jresult ;
81592   Dali::Toolkit::Slider result;
81593
81594   {
81595     try {
81596       result = Dali::Toolkit::Slider::New();
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81604       };
81605     } catch (Dali::DaliException e) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81608       };
81609     } catch (...) {
81610       {
81611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81612       };
81613     }
81614   }
81615
81616   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81622   void * jresult ;
81623   Dali::Toolkit::Slider *result = 0 ;
81624
81625   {
81626     try {
81627       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81628     } catch (std::out_of_range& e) {
81629       {
81630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81631       };
81632     } catch (std::exception& e) {
81633       {
81634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81635       };
81636     } catch (Dali::DaliException e) {
81637       {
81638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81639       };
81640     } catch (...) {
81641       {
81642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81643       };
81644     }
81645   }
81646
81647   jresult = (void *)result;
81648   return jresult;
81649 }
81650
81651
81652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81653   void * jresult ;
81654   Dali::Toolkit::Slider *arg1 = 0 ;
81655   Dali::Toolkit::Slider *result = 0 ;
81656
81657   arg1 = (Dali::Toolkit::Slider *)jarg1;
81658   if (!arg1) {
81659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81660     return 0;
81661   }
81662   {
81663     try {
81664       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81665     } catch (std::out_of_range& e) {
81666       {
81667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81668       };
81669     } catch (std::exception& e) {
81670       {
81671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81672       };
81673     } catch (Dali::DaliException e) {
81674       {
81675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81676       };
81677     } catch (...) {
81678       {
81679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81680       };
81681     }
81682   }
81683
81684   jresult = (void *)result;
81685   return jresult;
81686 }
81687
81688
81689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81690   void * jresult ;
81691   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81692   Dali::Toolkit::Slider *arg2 = 0 ;
81693   Dali::Toolkit::Slider *result = 0 ;
81694
81695   arg1 = (Dali::Toolkit::Slider *)jarg1;
81696   arg2 = (Dali::Toolkit::Slider *)jarg2;
81697   if (!arg2) {
81698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81699     return 0;
81700   }
81701   {
81702     try {
81703       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81704     } catch (std::out_of_range& e) {
81705       {
81706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81707       };
81708     } catch (std::exception& e) {
81709       {
81710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81711       };
81712     } catch (Dali::DaliException e) {
81713       {
81714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81715       };
81716     } catch (...) {
81717       {
81718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81719       };
81720     }
81721   }
81722
81723   jresult = (void *)result;
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81729   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81730
81731   arg1 = (Dali::Toolkit::Slider *)jarg1;
81732   {
81733     try {
81734       delete arg1;
81735     } catch (std::out_of_range& e) {
81736       {
81737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81738       };
81739     } catch (std::exception& e) {
81740       {
81741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81742       };
81743     } catch (Dali::DaliException e) {
81744       {
81745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81746       };
81747     } catch (...) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81750       };
81751     }
81752   }
81753
81754 }
81755
81756
81757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81758   void * jresult ;
81759   Dali::BaseHandle arg1 ;
81760   Dali::BaseHandle *argp1 ;
81761   Dali::Toolkit::Slider result;
81762
81763   argp1 = (Dali::BaseHandle *)jarg1;
81764   if (!argp1) {
81765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81766     return 0;
81767   }
81768   arg1 = *argp1;
81769   {
81770     try {
81771       result = Dali::Toolkit::Slider::DownCast(arg1);
81772     } catch (std::out_of_range& e) {
81773       {
81774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81775       };
81776     } catch (std::exception& e) {
81777       {
81778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81779       };
81780     } catch (Dali::DaliException e) {
81781       {
81782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81783       };
81784     } catch (...) {
81785       {
81786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81787       };
81788     }
81789   }
81790
81791   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81792   return jresult;
81793 }
81794
81795
81796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81797   void * jresult ;
81798   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81799   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81800
81801   arg1 = (Dali::Toolkit::Slider *)jarg1;
81802   {
81803     try {
81804       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81805     } catch (std::out_of_range& e) {
81806       {
81807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81808       };
81809     } catch (std::exception& e) {
81810       {
81811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81812       };
81813     } catch (Dali::DaliException e) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81816       };
81817     } catch (...) {
81818       {
81819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81820       };
81821     }
81822   }
81823
81824   jresult = (void *)result;
81825   return jresult;
81826 }
81827
81828
81829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81830   void * jresult ;
81831   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81832   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81833
81834   arg1 = (Dali::Toolkit::Slider *)jarg1;
81835   {
81836     try {
81837       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81838     } catch (std::out_of_range& e) {
81839       {
81840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81841       };
81842     } catch (std::exception& e) {
81843       {
81844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81845       };
81846     } catch (Dali::DaliException e) {
81847       {
81848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81849       };
81850     } catch (...) {
81851       {
81852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81853       };
81854     }
81855   }
81856
81857   jresult = (void *)result;
81858   return jresult;
81859 }
81860
81861
81862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81863   void * jresult ;
81864   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81865   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81866
81867   arg1 = (Dali::Toolkit::Slider *)jarg1;
81868   {
81869     try {
81870       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81871     } catch (std::out_of_range& e) {
81872       {
81873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81874       };
81875     } catch (std::exception& e) {
81876       {
81877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (Dali::DaliException e) {
81880       {
81881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81882       };
81883     } catch (...) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81886       };
81887     }
81888   }
81889
81890   jresult = (void *)result;
81891   return jresult;
81892 }
81893
81894
81895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81896   int jresult ;
81897   int result;
81898
81899   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81900   jresult = (int)result;
81901   return jresult;
81902 }
81903
81904
81905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81906   int jresult ;
81907   int result;
81908
81909   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81910   jresult = (int)result;
81911   return jresult;
81912 }
81913
81914
81915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81916   int jresult ;
81917   int result;
81918
81919   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81920   jresult = (int)result;
81921   return jresult;
81922 }
81923
81924
81925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81926   int jresult ;
81927   int result;
81928
81929   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81930   jresult = (int)result;
81931   return jresult;
81932 }
81933
81934
81935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81936   int result;
81937
81938   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81939
81940   return result;
81941 }
81942
81943
81944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81945   void * jresult ;
81946   Dali::Toolkit::VideoView::Property *result = 0 ;
81947
81948   {
81949     try {
81950       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (Dali::DaliException e) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81962       };
81963     } catch (...) {
81964       {
81965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81966       };
81967     }
81968   }
81969
81970   jresult = (void *)result;
81971   return jresult;
81972 }
81973
81974
81975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81976   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81977
81978   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81979   {
81980     try {
81981       delete arg1;
81982     } catch (std::out_of_range& e) {
81983       {
81984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81985       };
81986     } catch (std::exception& e) {
81987       {
81988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81989       };
81990     } catch (Dali::DaliException e) {
81991       {
81992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81993       };
81994     } catch (...) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81997       };
81998     }
81999   }
82000
82001 }
82002
82003
82004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82005   void * jresult ;
82006   Dali::Toolkit::VideoView result;
82007
82008   {
82009     try {
82010       result = Dali::Toolkit::VideoView::New();
82011     } catch (std::out_of_range& e) {
82012       {
82013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82014       };
82015     } catch (std::exception& e) {
82016       {
82017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82018       };
82019     } catch (Dali::DaliException e) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82022       };
82023     } catch (...) {
82024       {
82025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82026       };
82027     }
82028   }
82029
82030   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82031   return jresult;
82032 }
82033
82034
82035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82036   void * jresult ;
82037   std::string *arg1 = 0 ;
82038   Dali::Toolkit::VideoView result;
82039
82040   if (!jarg1) {
82041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82042     return 0;
82043   }
82044   std::string arg1_str(jarg1);
82045   arg1 = &arg1_str;
82046   {
82047     try {
82048       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82049     } catch (std::out_of_range& e) {
82050       {
82051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82052       };
82053     } catch (std::exception& e) {
82054       {
82055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82056       };
82057     } catch (Dali::DaliException e) {
82058       {
82059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82060       };
82061     } catch (...) {
82062       {
82063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82064       };
82065     }
82066   }
82067
82068   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82069
82070   //argout typemap for const std::string&
82071
82072   return jresult;
82073 }
82074
82075
82076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82077   void * jresult ;
82078   Dali::Toolkit::VideoView result;
82079   {
82080     try {
82081       result = Dali::Toolkit::VideoView::New(swCodec);
82082     } catch (std::out_of_range& e) {
82083       {
82084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82085       };
82086     } catch (std::exception& e) {
82087       {
82088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82089       };
82090     } catch (Dali::DaliException e) {
82091       {
82092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82093       };
82094     } catch (...) {
82095       {
82096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82097       };
82098     }
82099   }
82100
82101   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82102
82103   //argout typemap for const std::string&
82104
82105   return jresult;
82106 }
82107
82108
82109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82110   void * jresult ;
82111   std::string *arg1 = 0 ;
82112   Dali::Toolkit::VideoView result;
82113
82114   if (!jarg1) {
82115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82116     return 0;
82117   }
82118   std::string arg1_str(jarg1);
82119   arg1 = &arg1_str;
82120   {
82121     try {
82122       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
82123     } catch (std::out_of_range& e) {
82124       {
82125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82126       };
82127     } catch (std::exception& e) {
82128       {
82129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82130       };
82131     } catch (Dali::DaliException e) {
82132       {
82133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82134       };
82135     } catch (...) {
82136       {
82137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82138       };
82139     }
82140   }
82141
82142   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82143
82144   //argout typemap for const std::string&
82145
82146   return jresult;
82147 }
82148
82149
82150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82151   void * jresult ;
82152   Dali::Toolkit::VideoView *result = 0 ;
82153
82154   {
82155     try {
82156       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82157     } catch (std::out_of_range& e) {
82158       {
82159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82160       };
82161     } catch (std::exception& e) {
82162       {
82163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82164       };
82165     } catch (Dali::DaliException e) {
82166       {
82167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82168       };
82169     } catch (...) {
82170       {
82171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82172       };
82173     }
82174   }
82175
82176   jresult = (void *)result;
82177   return jresult;
82178 }
82179
82180
82181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82182   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82183
82184   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82185   {
82186     try {
82187       delete arg1;
82188     } catch (std::out_of_range& e) {
82189       {
82190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82191       };
82192     } catch (std::exception& e) {
82193       {
82194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82195       };
82196     } catch (Dali::DaliException e) {
82197       {
82198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82199       };
82200     } catch (...) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82203       };
82204     }
82205   }
82206
82207 }
82208
82209
82210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82211   void * jresult ;
82212   Dali::Toolkit::VideoView *arg1 = 0 ;
82213   Dali::Toolkit::VideoView *result = 0 ;
82214
82215   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82216   if (!arg1) {
82217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82218     return 0;
82219   }
82220   {
82221     try {
82222       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82223     } catch (std::out_of_range& e) {
82224       {
82225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (std::exception& e) {
82228       {
82229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (Dali::DaliException e) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82234       };
82235     } catch (...) {
82236       {
82237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82238       };
82239     }
82240   }
82241
82242   jresult = (void *)result;
82243   return jresult;
82244 }
82245
82246
82247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82248   void * jresult ;
82249   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82250   Dali::Toolkit::VideoView *arg2 = 0 ;
82251   Dali::Toolkit::VideoView *result = 0 ;
82252
82253   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82254   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82255   if (!arg2) {
82256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82257     return 0;
82258   }
82259   {
82260     try {
82261       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82262     } catch (std::out_of_range& e) {
82263       {
82264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (std::exception& e) {
82267       {
82268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82269       };
82270     } catch (Dali::DaliException e) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82273       };
82274     } catch (...) {
82275       {
82276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82277       };
82278     }
82279   }
82280
82281   jresult = (void *)result;
82282   return jresult;
82283 }
82284
82285
82286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82287   void * jresult ;
82288   Dali::BaseHandle arg1 ;
82289   Dali::BaseHandle *argp1 ;
82290   Dali::Toolkit::VideoView result;
82291
82292   argp1 = (Dali::BaseHandle *)jarg1;
82293   if (!argp1) {
82294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82295     return 0;
82296   }
82297   arg1 = *argp1;
82298   {
82299     try {
82300       result = Dali::Toolkit::VideoView::DownCast(arg1);
82301     } catch (std::out_of_range& e) {
82302       {
82303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82304       };
82305     } catch (std::exception& e) {
82306       {
82307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82308       };
82309     } catch (Dali::DaliException e) {
82310       {
82311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82312       };
82313     } catch (...) {
82314       {
82315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82316       };
82317     }
82318   }
82319
82320   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82321   return jresult;
82322 }
82323
82324
82325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82326   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82327
82328   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82329   {
82330     try {
82331       (arg1)->Play();
82332     } catch (std::out_of_range& e) {
82333       {
82334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82335       };
82336     } catch (std::exception& e) {
82337       {
82338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82339       };
82340     } catch (Dali::DaliException e) {
82341       {
82342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82343       };
82344     } catch (...) {
82345       {
82346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82347       };
82348     }
82349   }
82350
82351 }
82352
82353
82354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82355   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82356
82357   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82358   {
82359     try {
82360       (arg1)->Pause();
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82376       };
82377     }
82378   }
82379
82380 }
82381
82382
82383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82384   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82385
82386   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82387   {
82388     try {
82389       (arg1)->Stop();
82390     } catch (std::out_of_range& e) {
82391       {
82392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82393       };
82394     } catch (std::exception& e) {
82395       {
82396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82397       };
82398     } catch (Dali::DaliException e) {
82399       {
82400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82401       };
82402     } catch (...) {
82403       {
82404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82405       };
82406     }
82407   }
82408
82409 }
82410
82411
82412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82413   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82414   int arg2 ;
82415
82416   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82417   arg2 = (int)jarg2;
82418   {
82419     try {
82420       (arg1)->Forward(arg2);
82421     } catch (std::out_of_range& e) {
82422       {
82423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82424       };
82425     } catch (std::exception& e) {
82426       {
82427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82428       };
82429     } catch (Dali::DaliException e) {
82430       {
82431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82432       };
82433     } catch (...) {
82434       {
82435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82436       };
82437     }
82438   }
82439
82440 }
82441
82442
82443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82444   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82445   int arg2 ;
82446
82447   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82448   arg2 = (int)jarg2;
82449   {
82450     try {
82451       (arg1)->Backward(arg2);
82452     } catch (std::out_of_range& e) {
82453       {
82454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82455       };
82456     } catch (std::exception& e) {
82457       {
82458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82459       };
82460     } catch (Dali::DaliException e) {
82461       {
82462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82463       };
82464     } catch (...) {
82465       {
82466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82467       };
82468     }
82469   }
82470
82471 }
82472
82473
82474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82475   void * jresult ;
82476   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82477   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82478
82479   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82480   {
82481     try {
82482       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82483     } catch (std::out_of_range& e) {
82484       {
82485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82486       };
82487     } catch (std::exception& e) {
82488       {
82489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82490       };
82491     } catch (Dali::DaliException e) {
82492       {
82493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82494       };
82495     } catch (...) {
82496       {
82497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82498       };
82499     }
82500   }
82501
82502   jresult = (void *)result;
82503   return jresult;
82504 }
82505
82506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82507 {
82508   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82509   if( arg1 == nullptr )
82510   {
82511     DALI_LOG_ERROR("VideoView is nullptr!");
82512     return nullptr;
82513   }
82514   void * ret = nullptr;
82515   {
82516     try{
82517
82518       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82519       ret = Dali::AnyCast< void * >( result );
82520
82521     } catch (std::out_of_range& e) {
82522       {
82523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82524       };
82525     } catch (std::exception& e) {
82526       {
82527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82528       };
82529     } catch (Dali::DaliException e) {
82530       {
82531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82532       };
82533     } catch (...) {
82534       {
82535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82536       };
82537     }
82538   }
82539   return ret;
82540 }
82541
82542
82543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82544   int jresult ;
82545   int result;
82546
82547   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82548   jresult = (int)result;
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82554   int jresult ;
82555   int result;
82556
82557   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82558   jresult = (int)result;
82559   return jresult;
82560 }
82561
82562
82563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82564   int jresult ;
82565   int result;
82566
82567   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82568   jresult = (int)result;
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82574   int jresult ;
82575   int result;
82576
82577   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82578   jresult = (int)result;
82579   return jresult;
82580 }
82581
82582
82583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82584   int jresult ;
82585   int result;
82586
82587   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82588   jresult = (int)result;
82589   return jresult;
82590 }
82591
82592
82593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82594   int jresult ;
82595   int result;
82596
82597   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82598   jresult = (int)result;
82599   return jresult;
82600 }
82601
82602
82603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82604   int jresult ;
82605   int result;
82606
82607   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82608   jresult = (int)result;
82609   return jresult;
82610 }
82611
82612
82613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82614   int jresult ;
82615   int result;
82616
82617   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82618   jresult = (int)result;
82619   return jresult;
82620 }
82621
82622
82623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82624   int jresult ;
82625   int result;
82626
82627   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82628   jresult = (int)result;
82629   return jresult;
82630 }
82631
82632
82633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82634   int jresult ;
82635   int result;
82636
82637   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82638   jresult = (int)result;
82639   return jresult;
82640 }
82641
82642
82643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82644   int jresult ;
82645   int result;
82646
82647   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82648   jresult = (int)result;
82649   return jresult;
82650 }
82651
82652
82653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82654   int jresult ;
82655   int result;
82656
82657   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82658   jresult = (int)result;
82659   return jresult;
82660 }
82661
82662
82663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82664   int jresult ;
82665   int result;
82666
82667   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82668   jresult = (int)result;
82669   return jresult;
82670 }
82671
82672
82673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82674   int jresult ;
82675   int result;
82676
82677   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82678   jresult = (int)result;
82679   return jresult;
82680 }
82681
82682
82683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82684   int jresult ;
82685   int result;
82686
82687   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82688   jresult = (int)result;
82689   return jresult;
82690 }
82691
82692
82693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82694   int jresult ;
82695   int result;
82696
82697   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82698   jresult = (int)result;
82699   return jresult;
82700 }
82701
82702
82703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82704   int jresult ;
82705   int result;
82706
82707   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82708   jresult = (int)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82714   int jresult ;
82715   int result;
82716
82717   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82718   jresult = (int)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82724   int jresult ;
82725   int result;
82726
82727   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82728   jresult = (int)result;
82729   return jresult;
82730 }
82731
82732
82733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82734   int jresult ;
82735   int result;
82736
82737   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82738   jresult = (int)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82744   int jresult ;
82745   int result;
82746
82747   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82748   jresult = (int)result;
82749   return jresult;
82750 }
82751
82752
82753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82754   void * jresult ;
82755   Dali::Toolkit::Popup::Property *result = 0 ;
82756
82757   {
82758     try {
82759       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82760     } catch (std::out_of_range& e) {
82761       {
82762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82763       };
82764     } catch (std::exception& e) {
82765       {
82766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82767       };
82768     } catch (Dali::DaliException e) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82771       };
82772     } catch (...) {
82773       {
82774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82775       };
82776     }
82777   }
82778
82779   jresult = (void *)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82785   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82786
82787   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82788   {
82789     try {
82790       delete arg1;
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82806       };
82807     }
82808   }
82809
82810 }
82811
82812
82813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82814   void * jresult ;
82815   Dali::Toolkit::Popup *result = 0 ;
82816
82817   {
82818     try {
82819       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82820     } catch (std::out_of_range& e) {
82821       {
82822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82823       };
82824     } catch (std::exception& e) {
82825       {
82826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82827       };
82828     } catch (Dali::DaliException e) {
82829       {
82830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82831       };
82832     } catch (...) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82835       };
82836     }
82837   }
82838
82839   jresult = (void *)result;
82840   return jresult;
82841 }
82842
82843
82844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82845   void * jresult ;
82846   Dali::Toolkit::Popup result;
82847
82848   {
82849     try {
82850       result = Dali::Toolkit::Popup::New();
82851     } catch (std::out_of_range& e) {
82852       {
82853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82854       };
82855     } catch (std::exception& e) {
82856       {
82857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (Dali::DaliException e) {
82860       {
82861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82862       };
82863     } catch (...) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82866       };
82867     }
82868   }
82869
82870   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82871   return jresult;
82872 }
82873
82874
82875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82876   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82877
82878   arg1 = (Dali::Toolkit::Popup *)jarg1;
82879   {
82880     try {
82881       delete arg1;
82882     } catch (std::out_of_range& e) {
82883       {
82884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82885       };
82886     } catch (std::exception& e) {
82887       {
82888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82889       };
82890     } catch (Dali::DaliException e) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82893       };
82894     } catch (...) {
82895       {
82896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82897       };
82898     }
82899   }
82900
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82905   void * jresult ;
82906   Dali::Toolkit::Popup *arg1 = 0 ;
82907   Dali::Toolkit::Popup *result = 0 ;
82908
82909   arg1 = (Dali::Toolkit::Popup *)jarg1;
82910   if (!arg1) {
82911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82912     return 0;
82913   }
82914   {
82915     try {
82916       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (Dali::DaliException e) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82928       };
82929     } catch (...) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82932       };
82933     }
82934   }
82935
82936   jresult = (void *)result;
82937   return jresult;
82938 }
82939
82940
82941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82942   void * jresult ;
82943   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82944   Dali::Toolkit::Popup *arg2 = 0 ;
82945   Dali::Toolkit::Popup *result = 0 ;
82946
82947   arg1 = (Dali::Toolkit::Popup *)jarg1;
82948   arg2 = (Dali::Toolkit::Popup *)jarg2;
82949   if (!arg2) {
82950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82951     return 0;
82952   }
82953   {
82954     try {
82955       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82956     } catch (std::out_of_range& e) {
82957       {
82958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82959       };
82960     } catch (std::exception& e) {
82961       {
82962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82963       };
82964     } catch (Dali::DaliException e) {
82965       {
82966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82967       };
82968     } catch (...) {
82969       {
82970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82971       };
82972     }
82973   }
82974
82975   jresult = (void *)result;
82976   return jresult;
82977 }
82978
82979
82980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82981   void * jresult ;
82982   Dali::BaseHandle arg1 ;
82983   Dali::BaseHandle *argp1 ;
82984   Dali::Toolkit::Popup result;
82985
82986   argp1 = (Dali::BaseHandle *)jarg1;
82987   if (!argp1) {
82988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82989     return 0;
82990   }
82991   arg1 = *argp1;
82992   {
82993     try {
82994       result = Dali::Toolkit::Popup::DownCast(arg1);
82995     } catch (std::out_of_range& e) {
82996       {
82997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82998       };
82999     } catch (std::exception& e) {
83000       {
83001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83002       };
83003     } catch (Dali::DaliException e) {
83004       {
83005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83006       };
83007     } catch (...) {
83008       {
83009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83010       };
83011     }
83012   }
83013
83014   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83015   return jresult;
83016 }
83017
83018
83019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83020   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83021   Dali::Actor arg2 ;
83022   Dali::Actor *argp2 ;
83023
83024   arg1 = (Dali::Toolkit::Popup *)jarg1;
83025   argp2 = (Dali::Actor *)jarg2;
83026   if (!argp2) {
83027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83028     return ;
83029   }
83030   arg2 = *argp2;
83031   {
83032     try {
83033       (arg1)->SetTitle(arg2);
83034     } catch (std::out_of_range& e) {
83035       {
83036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83037       };
83038     } catch (std::exception& e) {
83039       {
83040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83041       };
83042     } catch (Dali::DaliException e) {
83043       {
83044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83045       };
83046     } catch (...) {
83047       {
83048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83049       };
83050     }
83051   }
83052
83053 }
83054
83055
83056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83057   void * jresult ;
83058   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83059   Dali::Actor result;
83060
83061   arg1 = (Dali::Toolkit::Popup *)jarg1;
83062   {
83063     try {
83064       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83065     } catch (std::out_of_range& e) {
83066       {
83067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83068       };
83069     } catch (std::exception& e) {
83070       {
83071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83072       };
83073     } catch (Dali::DaliException e) {
83074       {
83075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83076       };
83077     } catch (...) {
83078       {
83079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83080       };
83081     }
83082   }
83083
83084   jresult = new Dali::Actor((const Dali::Actor &)result);
83085   return jresult;
83086 }
83087
83088
83089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83090   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83091   Dali::Actor arg2 ;
83092   Dali::Actor *argp2 ;
83093
83094   arg1 = (Dali::Toolkit::Popup *)jarg1;
83095   argp2 = (Dali::Actor *)jarg2;
83096   if (!argp2) {
83097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83098     return ;
83099   }
83100   arg2 = *argp2;
83101   {
83102     try {
83103       (arg1)->SetContent(arg2);
83104     } catch (std::out_of_range& e) {
83105       {
83106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83107       };
83108     } catch (std::exception& e) {
83109       {
83110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83111       };
83112     } catch (Dali::DaliException e) {
83113       {
83114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83115       };
83116     } catch (...) {
83117       {
83118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83119       };
83120     }
83121   }
83122
83123 }
83124
83125
83126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83127   void * jresult ;
83128   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83129   Dali::Actor result;
83130
83131   arg1 = (Dali::Toolkit::Popup *)jarg1;
83132   {
83133     try {
83134       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83135     } catch (std::out_of_range& e) {
83136       {
83137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83138       };
83139     } catch (std::exception& e) {
83140       {
83141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83142       };
83143     } catch (Dali::DaliException e) {
83144       {
83145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83146       };
83147     } catch (...) {
83148       {
83149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83150       };
83151     }
83152   }
83153
83154   jresult = new Dali::Actor((const Dali::Actor &)result);
83155   return jresult;
83156 }
83157
83158
83159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83160   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83161   Dali::Actor arg2 ;
83162   Dali::Actor *argp2 ;
83163
83164   arg1 = (Dali::Toolkit::Popup *)jarg1;
83165   argp2 = (Dali::Actor *)jarg2;
83166   if (!argp2) {
83167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83168     return ;
83169   }
83170   arg2 = *argp2;
83171   {
83172     try {
83173       (arg1)->SetFooter(arg2);
83174     } catch (std::out_of_range& e) {
83175       {
83176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83177       };
83178     } catch (std::exception& e) {
83179       {
83180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83181       };
83182     } catch (Dali::DaliException e) {
83183       {
83184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83185       };
83186     } catch (...) {
83187       {
83188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83189       };
83190     }
83191   }
83192
83193 }
83194
83195
83196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83197   void * jresult ;
83198   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83199   Dali::Actor result;
83200
83201   arg1 = (Dali::Toolkit::Popup *)jarg1;
83202   {
83203     try {
83204       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83205     } catch (std::out_of_range& e) {
83206       {
83207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83208       };
83209     } catch (std::exception& e) {
83210       {
83211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83212       };
83213     } catch (Dali::DaliException e) {
83214       {
83215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83216       };
83217     } catch (...) {
83218       {
83219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83220       };
83221     }
83222   }
83223
83224   jresult = new Dali::Actor((const Dali::Actor &)result);
83225   return jresult;
83226 }
83227
83228
83229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83230   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83231   Dali::Toolkit::Popup::DisplayState arg2 ;
83232
83233   arg1 = (Dali::Toolkit::Popup *)jarg1;
83234   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83235   {
83236     try {
83237       (arg1)->SetDisplayState(arg2);
83238     } catch (std::out_of_range& e) {
83239       {
83240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83241       };
83242     } catch (std::exception& e) {
83243       {
83244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83245       };
83246     } catch (Dali::DaliException e) {
83247       {
83248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83249       };
83250     } catch (...) {
83251       {
83252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83253       };
83254     }
83255   }
83256
83257 }
83258
83259
83260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83261   int jresult ;
83262   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83263   Dali::Toolkit::Popup::DisplayState result;
83264
83265   arg1 = (Dali::Toolkit::Popup *)jarg1;
83266   {
83267     try {
83268       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83269     } catch (std::out_of_range& e) {
83270       {
83271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83272       };
83273     } catch (std::exception& e) {
83274       {
83275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83276       };
83277     } catch (Dali::DaliException e) {
83278       {
83279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83280       };
83281     } catch (...) {
83282       {
83283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83284       };
83285     }
83286   }
83287
83288   jresult = (int)result;
83289   return jresult;
83290 }
83291
83292
83293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83294   void * jresult ;
83295   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83296   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83297
83298   arg1 = (Dali::Toolkit::Popup *)jarg1;
83299   {
83300     try {
83301       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83302     } catch (std::out_of_range& e) {
83303       {
83304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83305       };
83306     } catch (std::exception& e) {
83307       {
83308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83309       };
83310     } catch (Dali::DaliException e) {
83311       {
83312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83313       };
83314     } catch (...) {
83315       {
83316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83317       };
83318     }
83319   }
83320
83321   jresult = (void *)result;
83322   return jresult;
83323 }
83324
83325
83326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83327   void * jresult ;
83328   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83329   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83330
83331   arg1 = (Dali::Toolkit::Popup *)jarg1;
83332   {
83333     try {
83334       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83335     } catch (std::out_of_range& e) {
83336       {
83337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83338       };
83339     } catch (std::exception& e) {
83340       {
83341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83342       };
83343     } catch (Dali::DaliException e) {
83344       {
83345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83346       };
83347     } catch (...) {
83348       {
83349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83350       };
83351     }
83352   }
83353
83354   jresult = (void *)result;
83355   return jresult;
83356 }
83357
83358
83359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83360   void * jresult ;
83361   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83362   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83363
83364   arg1 = (Dali::Toolkit::Popup *)jarg1;
83365   {
83366     try {
83367       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83368     } catch (std::out_of_range& e) {
83369       {
83370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83371       };
83372     } catch (std::exception& e) {
83373       {
83374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83375       };
83376     } catch (Dali::DaliException e) {
83377       {
83378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83379       };
83380     } catch (...) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83383       };
83384     }
83385   }
83386
83387   jresult = (void *)result;
83388   return jresult;
83389 }
83390
83391
83392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83393   void * jresult ;
83394   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83395   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83396
83397   arg1 = (Dali::Toolkit::Popup *)jarg1;
83398   {
83399     try {
83400       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83401     } catch (std::out_of_range& e) {
83402       {
83403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83404       };
83405     } catch (std::exception& e) {
83406       {
83407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83408       };
83409     } catch (Dali::DaliException e) {
83410       {
83411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83412       };
83413     } catch (...) {
83414       {
83415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83416       };
83417     }
83418   }
83419
83420   jresult = (void *)result;
83421   return jresult;
83422 }
83423
83424
83425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83426   void * jresult ;
83427   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83428   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83429
83430   arg1 = (Dali::Toolkit::Popup *)jarg1;
83431   {
83432     try {
83433       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83434     } catch (std::out_of_range& e) {
83435       {
83436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83437       };
83438     } catch (std::exception& e) {
83439       {
83440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83441       };
83442     } catch (Dali::DaliException e) {
83443       {
83444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83445       };
83446     } catch (...) {
83447       {
83448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83449       };
83450     }
83451   }
83452
83453   jresult = (void *)result;
83454   return jresult;
83455 }
83456
83457
83458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83459   int jresult ;
83460   int result;
83461
83462   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83463   jresult = (int)result;
83464   return jresult;
83465 }
83466
83467
83468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83469   int jresult ;
83470   int result;
83471
83472   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83473   jresult = (int)result;
83474   return jresult;
83475 }
83476
83477
83478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83479   int jresult ;
83480   int result;
83481
83482   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83483   jresult = (int)result;
83484   return jresult;
83485 }
83486
83487
83488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83489   int jresult ;
83490   int result;
83491
83492   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83493   jresult = (int)result;
83494   return jresult;
83495 }
83496
83497
83498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83499   int jresult ;
83500   int result;
83501
83502   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83503   jresult = (int)result;
83504   return jresult;
83505 }
83506
83507
83508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83509   int jresult ;
83510   int result;
83511
83512   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83513   jresult = (int)result;
83514   return jresult;
83515 }
83516
83517
83518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83519   int jresult ;
83520   int result;
83521
83522   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83523   jresult = (int)result;
83524   return jresult;
83525 }
83526
83527
83528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83529   int jresult ;
83530   int result;
83531
83532   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83533   jresult = (int)result;
83534   return jresult;
83535 }
83536
83537
83538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83539   int jresult ;
83540   int result;
83541
83542   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83543   jresult = (int)result;
83544   return jresult;
83545 }
83546
83547
83548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83549   void * jresult ;
83550   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83551
83552   {
83553     try {
83554       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83555     } catch (std::out_of_range& e) {
83556       {
83557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83558       };
83559     } catch (std::exception& e) {
83560       {
83561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83562       };
83563     } catch (Dali::DaliException e) {
83564       {
83565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83566       };
83567     } catch (...) {
83568       {
83569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83570       };
83571     }
83572   }
83573
83574   jresult = (void *)result;
83575   return jresult;
83576 }
83577
83578
83579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83580   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83581
83582   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83583   {
83584     try {
83585       delete arg1;
83586     } catch (std::out_of_range& e) {
83587       {
83588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83589       };
83590     } catch (std::exception& e) {
83591       {
83592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83593       };
83594     } catch (Dali::DaliException e) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83597       };
83598     } catch (...) {
83599       {
83600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83601       };
83602     }
83603   }
83604
83605 }
83606
83607
83608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83609   void * jresult ;
83610   Dali::Toolkit::ProgressBar result;
83611
83612   {
83613     try {
83614       result = Dali::Toolkit::ProgressBar::New();
83615     } catch (std::out_of_range& e) {
83616       {
83617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83618       };
83619     } catch (std::exception& e) {
83620       {
83621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (Dali::DaliException e) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83626       };
83627     } catch (...) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83630       };
83631     }
83632   }
83633
83634   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83635   return jresult;
83636 }
83637
83638
83639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83640   void * jresult ;
83641   Dali::Toolkit::ProgressBar *result = 0 ;
83642
83643   {
83644     try {
83645       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83646     } catch (std::out_of_range& e) {
83647       {
83648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83649       };
83650     } catch (std::exception& e) {
83651       {
83652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83653       };
83654     } catch (Dali::DaliException e) {
83655       {
83656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83657       };
83658     } catch (...) {
83659       {
83660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83661       };
83662     }
83663   }
83664
83665   jresult = (void *)result;
83666   return jresult;
83667 }
83668
83669
83670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83671   void * jresult ;
83672   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83673   Dali::Toolkit::ProgressBar *result = 0 ;
83674
83675   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83676   if (!arg1) {
83677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83678     return 0;
83679   }
83680   {
83681     try {
83682       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83683     } catch (std::out_of_range& e) {
83684       {
83685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83686       };
83687     } catch (std::exception& e) {
83688       {
83689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (Dali::DaliException e) {
83692       {
83693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83694       };
83695     } catch (...) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83698       };
83699     }
83700   }
83701
83702   jresult = (void *)result;
83703   return jresult;
83704 }
83705
83706
83707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83708   void * jresult ;
83709   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83710   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83711   Dali::Toolkit::ProgressBar *result = 0 ;
83712
83713   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83714   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83715   if (!arg2) {
83716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83717     return 0;
83718   }
83719   {
83720     try {
83721       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83722     } catch (std::out_of_range& e) {
83723       {
83724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (std::exception& e) {
83727       {
83728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83729       };
83730     } catch (Dali::DaliException e) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83733       };
83734     } catch (...) {
83735       {
83736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83737       };
83738     }
83739   }
83740
83741   jresult = (void *)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83747   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83748
83749   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83750   {
83751     try {
83752       delete arg1;
83753     } catch (std::out_of_range& e) {
83754       {
83755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83756       };
83757     } catch (std::exception& e) {
83758       {
83759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83760       };
83761     } catch (Dali::DaliException e) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83764       };
83765     } catch (...) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83768       };
83769     }
83770   }
83771
83772 }
83773
83774
83775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83776   void * jresult ;
83777   Dali::BaseHandle arg1 ;
83778   Dali::BaseHandle *argp1 ;
83779   Dali::Toolkit::ProgressBar result;
83780
83781   argp1 = (Dali::BaseHandle *)jarg1;
83782   if (!argp1) {
83783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83784     return 0;
83785   }
83786   arg1 = *argp1;
83787   {
83788     try {
83789       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83790     } catch (std::out_of_range& e) {
83791       {
83792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83793       };
83794     } catch (std::exception& e) {
83795       {
83796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83797       };
83798     } catch (Dali::DaliException e) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83801       };
83802     } catch (...) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83805       };
83806     }
83807   }
83808
83809   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83810   return jresult;
83811 }
83812
83813
83814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83815   void * jresult ;
83816   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83817   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83818
83819   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83820   {
83821     try {
83822       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83823     } catch (std::out_of_range& e) {
83824       {
83825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (std::exception& e) {
83828       {
83829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (Dali::DaliException e) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83834       };
83835     } catch (...) {
83836       {
83837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83838       };
83839     }
83840   }
83841
83842   jresult = (void *)result;
83843   return jresult;
83844 }
83845
83846
83847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83848   void * jresult ;
83849   Dali::Toolkit::GaussianBlurView *result = 0 ;
83850
83851   {
83852     try {
83853       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83854     } catch (std::out_of_range& e) {
83855       {
83856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83857       };
83858     } catch (std::exception& e) {
83859       {
83860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83861       };
83862     } catch (Dali::DaliException e) {
83863       {
83864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83865       };
83866     } catch (...) {
83867       {
83868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83869       };
83870     }
83871   }
83872
83873   jresult = (void *)result;
83874   return jresult;
83875 }
83876
83877
83878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83879   void * jresult ;
83880   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83881   Dali::Toolkit::GaussianBlurView *result = 0 ;
83882
83883   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83884   if (!arg1) {
83885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83886     return 0;
83887   }
83888   {
83889     try {
83890       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83891     } catch (std::out_of_range& e) {
83892       {
83893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83894       };
83895     } catch (std::exception& e) {
83896       {
83897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (Dali::DaliException e) {
83900       {
83901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83902       };
83903     } catch (...) {
83904       {
83905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83906       };
83907     }
83908   }
83909
83910   jresult = (void *)result;
83911   return jresult;
83912 }
83913
83914
83915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83916   void * jresult ;
83917   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83918   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83919   Dali::Toolkit::GaussianBlurView *result = 0 ;
83920
83921   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83922   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83923   if (!arg2) {
83924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83925     return 0;
83926   }
83927   {
83928     try {
83929       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83930     } catch (std::out_of_range& e) {
83931       {
83932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83933       };
83934     } catch (std::exception& e) {
83935       {
83936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83937       };
83938     } catch (Dali::DaliException e) {
83939       {
83940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83941       };
83942     } catch (...) {
83943       {
83944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83945       };
83946     }
83947   }
83948
83949   jresult = (void *)result;
83950   return jresult;
83951 }
83952
83953
83954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83955   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83956
83957   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83958   {
83959     try {
83960       delete arg1;
83961     } catch (std::out_of_range& e) {
83962       {
83963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83964       };
83965     } catch (std::exception& e) {
83966       {
83967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83968       };
83969     } catch (Dali::DaliException e) {
83970       {
83971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83972       };
83973     } catch (...) {
83974       {
83975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83976       };
83977     }
83978   }
83979
83980 }
83981
83982
83983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83984   void * jresult ;
83985   Dali::BaseHandle arg1 ;
83986   Dali::BaseHandle *argp1 ;
83987   Dali::Toolkit::GaussianBlurView result;
83988
83989   argp1 = (Dali::BaseHandle *)jarg1;
83990   if (!argp1) {
83991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83992     return 0;
83993   }
83994   arg1 = *argp1;
83995   {
83996     try {
83997       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83998     } catch (std::out_of_range& e) {
83999       {
84000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84001       };
84002     } catch (std::exception& e) {
84003       {
84004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84005       };
84006     } catch (Dali::DaliException e) {
84007       {
84008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84009       };
84010     } catch (...) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84013       };
84014     }
84015   }
84016
84017   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84018   return jresult;
84019 }
84020
84021
84022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84023   void * jresult ;
84024   Dali::Toolkit::GaussianBlurView result;
84025
84026   {
84027     try {
84028       result = Dali::Toolkit::GaussianBlurView::New();
84029     } catch (std::out_of_range& e) {
84030       {
84031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84032       };
84033     } catch (std::exception& e) {
84034       {
84035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (Dali::DaliException e) {
84038       {
84039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84040       };
84041     } catch (...) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84044       };
84045     }
84046   }
84047
84048   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84049   return jresult;
84050 }
84051
84052
84053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84054   void * jresult ;
84055   unsigned int arg1 ;
84056   float arg2 ;
84057   Dali::Pixel::Format arg3 ;
84058   float arg4 ;
84059   float arg5 ;
84060   bool arg6 ;
84061   Dali::Toolkit::GaussianBlurView result;
84062
84063   arg1 = (unsigned int)jarg1;
84064   arg2 = (float)jarg2;
84065   arg3 = (Dali::Pixel::Format)jarg3;
84066   arg4 = (float)jarg4;
84067   arg5 = (float)jarg5;
84068   arg6 = jarg6 ? true : false;
84069   {
84070     try {
84071       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84072     } catch (std::out_of_range& e) {
84073       {
84074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84075       };
84076     } catch (std::exception& e) {
84077       {
84078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84079       };
84080     } catch (Dali::DaliException e) {
84081       {
84082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84083       };
84084     } catch (...) {
84085       {
84086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84087       };
84088     }
84089   }
84090
84091   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84092   return jresult;
84093 }
84094
84095
84096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84097   void * jresult ;
84098   unsigned int arg1 ;
84099   float arg2 ;
84100   Dali::Pixel::Format arg3 ;
84101   float arg4 ;
84102   float arg5 ;
84103   Dali::Toolkit::GaussianBlurView result;
84104
84105   arg1 = (unsigned int)jarg1;
84106   arg2 = (float)jarg2;
84107   arg3 = (Dali::Pixel::Format)jarg3;
84108   arg4 = (float)jarg4;
84109   arg5 = (float)jarg5;
84110   {
84111     try {
84112       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84113     } catch (std::out_of_range& e) {
84114       {
84115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (std::exception& e) {
84118       {
84119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (Dali::DaliException e) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84124       };
84125     } catch (...) {
84126       {
84127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84128       };
84129     }
84130   }
84131
84132   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84133   return jresult;
84134 }
84135
84136
84137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84139   Dali::Actor arg2 ;
84140   Dali::Actor *argp2 ;
84141
84142   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84143   argp2 = (Dali::Actor *)jarg2;
84144   if (!argp2) {
84145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84146     return ;
84147   }
84148   arg2 = *argp2;
84149   {
84150     try {
84151       (arg1)->Add(arg2);
84152     } catch (std::out_of_range& e) {
84153       {
84154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84155       };
84156     } catch (std::exception& e) {
84157       {
84158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84159       };
84160     } catch (Dali::DaliException e) {
84161       {
84162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84163       };
84164     } catch (...) {
84165       {
84166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84167       };
84168     }
84169   }
84170
84171 }
84172
84173
84174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84175   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84176   Dali::Actor arg2 ;
84177   Dali::Actor *argp2 ;
84178
84179   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84180   argp2 = (Dali::Actor *)jarg2;
84181   if (!argp2) {
84182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84183     return ;
84184   }
84185   arg2 = *argp2;
84186   {
84187     try {
84188       (arg1)->Remove(arg2);
84189     } catch (std::out_of_range& e) {
84190       {
84191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84192       };
84193     } catch (std::exception& e) {
84194       {
84195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84196       };
84197     } catch (Dali::DaliException e) {
84198       {
84199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84200       };
84201     } catch (...) {
84202       {
84203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84204       };
84205     }
84206   }
84207
84208 }
84209
84210
84211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84212   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84213
84214   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84215   {
84216     try {
84217       (arg1)->Activate();
84218     } catch (std::out_of_range& e) {
84219       {
84220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84221       };
84222     } catch (std::exception& e) {
84223       {
84224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84225       };
84226     } catch (Dali::DaliException e) {
84227       {
84228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84229       };
84230     } catch (...) {
84231       {
84232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84233       };
84234     }
84235   }
84236
84237 }
84238
84239
84240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84241   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84242
84243   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84244   {
84245     try {
84246       (arg1)->ActivateOnce();
84247     } catch (std::out_of_range& e) {
84248       {
84249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84250       };
84251     } catch (std::exception& e) {
84252       {
84253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84254       };
84255     } catch (Dali::DaliException e) {
84256       {
84257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84258       };
84259     } catch (...) {
84260       {
84261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84262       };
84263     }
84264   }
84265
84266 }
84267
84268
84269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84270   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84271
84272   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84273   {
84274     try {
84275       (arg1)->Deactivate();
84276     } catch (std::out_of_range& e) {
84277       {
84278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84279       };
84280     } catch (std::exception& e) {
84281       {
84282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84283       };
84284     } catch (Dali::DaliException e) {
84285       {
84286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84287       };
84288     } catch (...) {
84289       {
84290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84291       };
84292     }
84293   }
84294
84295 }
84296
84297
84298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84299   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84300   Dali::Texture arg2 ;
84301   Dali::FrameBuffer arg3 ;
84302   Dali::Texture *argp2 ;
84303   Dali::FrameBuffer *argp3 ;
84304
84305   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84306   argp2 = (Dali::Texture *)jarg2;
84307   if (!argp2) {
84308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84309     return ;
84310   }
84311   arg2 = *argp2;
84312   argp3 = (Dali::FrameBuffer *)jarg3;
84313   if (!argp3) {
84314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84315     return ;
84316   }
84317   arg3 = *argp3;
84318   {
84319     try {
84320       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84321     } catch (std::out_of_range& e) {
84322       {
84323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84324       };
84325     } catch (std::exception& e) {
84326       {
84327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84328       };
84329     } catch (Dali::DaliException e) {
84330       {
84331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84332       };
84333     } catch (...) {
84334       {
84335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84336       };
84337     }
84338   }
84339
84340 }
84341
84342
84343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84344   int jresult ;
84345   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84346   Dali::Property::Index result;
84347
84348   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84349   {
84350     try {
84351       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84359       };
84360     } catch (Dali::DaliException e) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84363       };
84364     } catch (...) {
84365       {
84366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84367       };
84368     }
84369   }
84370
84371   jresult = result;
84372   return jresult;
84373 }
84374
84375
84376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84377   void * jresult ;
84378   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84379   Dali::FrameBuffer result;
84380
84381   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84382   {
84383     try {
84384       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84385     } catch (std::out_of_range& e) {
84386       {
84387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (std::exception& e) {
84390       {
84391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84392       };
84393     } catch (Dali::DaliException e) {
84394       {
84395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84396       };
84397     } catch (...) {
84398       {
84399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84400       };
84401     }
84402   }
84403
84404   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84405   return jresult;
84406 }
84407
84408
84409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84410   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84411   Dali::Vector4 *arg2 = 0 ;
84412
84413   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84414   arg2 = (Dali::Vector4 *)jarg2;
84415   if (!arg2) {
84416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84417     return ;
84418   }
84419   {
84420     try {
84421       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84422     } catch (std::out_of_range& e) {
84423       {
84424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84425       };
84426     } catch (std::exception& e) {
84427       {
84428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84429       };
84430     } catch (Dali::DaliException e) {
84431       {
84432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84433       };
84434     } catch (...) {
84435       {
84436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84437       };
84438     }
84439   }
84440
84441 }
84442
84443
84444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84445   void * jresult ;
84446   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84447   Dali::Vector4 result;
84448
84449   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84450   {
84451     try {
84452       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84453     } catch (std::out_of_range& e) {
84454       {
84455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84456       };
84457     } catch (std::exception& e) {
84458       {
84459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84460       };
84461     } catch (Dali::DaliException e) {
84462       {
84463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84464       };
84465     } catch (...) {
84466       {
84467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84468       };
84469     }
84470   }
84471
84472   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84473   return jresult;
84474 }
84475
84476
84477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84478   void * jresult ;
84479   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84480   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84481
84482   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84483   {
84484     try {
84485       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84486     } catch (std::out_of_range& e) {
84487       {
84488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84489       };
84490     } catch (std::exception& e) {
84491       {
84492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84493       };
84494     } catch (Dali::DaliException e) {
84495       {
84496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84497       };
84498     } catch (...) {
84499       {
84500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84501       };
84502     }
84503   }
84504
84505   jresult = (void *)result;
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84511   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84512
84513   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84514   {
84515     try {
84516       delete arg1;
84517     } catch (std::out_of_range& e) {
84518       {
84519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84520       };
84521     } catch (std::exception& e) {
84522       {
84523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84524       };
84525     } catch (Dali::DaliException e) {
84526       {
84527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84528       };
84529     } catch (...) {
84530       {
84531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84532       };
84533     }
84534   }
84535
84536 }
84537
84538
84539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84540   unsigned int jresult ;
84541   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84542   unsigned int result;
84543
84544   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84545   {
84546     try {
84547       result = (unsigned int)(arg1)->GetNumberOfPages();
84548     } catch (std::out_of_range& e) {
84549       {
84550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84551       };
84552     } catch (std::exception& e) {
84553       {
84554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84555       };
84556     } catch (Dali::DaliException e) {
84557       {
84558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84559       };
84560     } catch (...) {
84561       {
84562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84563       };
84564     }
84565   }
84566
84567   jresult = result;
84568   return jresult;
84569 }
84570
84571
84572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84573   void * jresult ;
84574   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84575   unsigned int arg2 ;
84576   Dali::Texture result;
84577
84578   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84579   arg2 = (unsigned int)jarg2;
84580   {
84581     try {
84582       result = (arg1)->NewPage(arg2);
84583     } catch (std::out_of_range& e) {
84584       {
84585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (std::exception& e) {
84588       {
84589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84590       };
84591     } catch (Dali::DaliException e) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84594       };
84595     } catch (...) {
84596       {
84597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84598       };
84599     }
84600   }
84601
84602   jresult = new Dali::Texture((const Dali::Texture &)result);
84603   return jresult;
84604 }
84605
84606
84607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84608   int jresult ;
84609   int result;
84610
84611   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84612   jresult = (int)result;
84613   return jresult;
84614 }
84615
84616
84617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84618   int jresult ;
84619   int result;
84620
84621   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84622   jresult = (int)result;
84623   return jresult;
84624 }
84625
84626
84627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84628   int jresult ;
84629   int result;
84630
84631   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84632   jresult = (int)result;
84633   return jresult;
84634 }
84635
84636
84637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84638   void * jresult ;
84639   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84640
84641   {
84642     try {
84643       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84644     } catch (std::out_of_range& e) {
84645       {
84646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84647       };
84648     } catch (std::exception& e) {
84649       {
84650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84651       };
84652     } catch (Dali::DaliException e) {
84653       {
84654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84655       };
84656     } catch (...) {
84657       {
84658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84659       };
84660     }
84661   }
84662
84663   jresult = (void *)result;
84664   return jresult;
84665 }
84666
84667
84668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84669   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84670
84671   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84672   {
84673     try {
84674       delete arg1;
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84690       };
84691     }
84692   }
84693
84694 }
84695
84696
84697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84698   void * jresult ;
84699   Dali::Toolkit::PageTurnView *result = 0 ;
84700
84701   {
84702     try {
84703       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84704     } catch (std::out_of_range& e) {
84705       {
84706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84707       };
84708     } catch (std::exception& e) {
84709       {
84710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84711       };
84712     } catch (Dali::DaliException e) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84715       };
84716     } catch (...) {
84717       {
84718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84719       };
84720     }
84721   }
84722
84723   jresult = (void *)result;
84724   return jresult;
84725 }
84726
84727
84728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84729   void * jresult ;
84730   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84731   Dali::Toolkit::PageTurnView *result = 0 ;
84732
84733   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84734   if (!arg1) {
84735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84736     return 0;
84737   }
84738   {
84739     try {
84740       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84741     } catch (std::out_of_range& e) {
84742       {
84743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (std::exception& e) {
84746       {
84747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (Dali::DaliException e) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84752       };
84753     } catch (...) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84756       };
84757     }
84758   }
84759
84760   jresult = (void *)result;
84761   return jresult;
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84766   void * jresult ;
84767   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84768   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84769   Dali::Toolkit::PageTurnView *result = 0 ;
84770
84771   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84772   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84773   if (!arg2) {
84774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84775     return 0;
84776   }
84777   {
84778     try {
84779       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (Dali::DaliException e) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84795       };
84796     }
84797   }
84798
84799   jresult = (void *)result;
84800   return jresult;
84801 }
84802
84803
84804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84805   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84806
84807   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84808   {
84809     try {
84810       delete arg1;
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84826       };
84827     }
84828   }
84829
84830 }
84831
84832
84833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84834   void * jresult ;
84835   Dali::BaseHandle arg1 ;
84836   Dali::BaseHandle *argp1 ;
84837   Dali::Toolkit::PageTurnView result;
84838
84839   argp1 = (Dali::BaseHandle *)jarg1;
84840   if (!argp1) {
84841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84842     return 0;
84843   }
84844   arg1 = *argp1;
84845   {
84846     try {
84847       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84848     } catch (std::out_of_range& e) {
84849       {
84850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (std::exception& e) {
84853       {
84854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84855       };
84856     } catch (Dali::DaliException e) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84859       };
84860     } catch (...) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84863       };
84864     }
84865   }
84866
84867   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84868   return jresult;
84869 }
84870
84871
84872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84873   void * jresult ;
84874   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84875   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84876
84877   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84878   {
84879     try {
84880       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84881     } catch (std::out_of_range& e) {
84882       {
84883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (std::exception& e) {
84886       {
84887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84888       };
84889     } catch (Dali::DaliException e) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84896       };
84897     }
84898   }
84899
84900   jresult = (void *)result;
84901   return jresult;
84902 }
84903
84904
84905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84906   void * jresult ;
84907   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84908   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84909
84910   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84911   {
84912     try {
84913       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84914     } catch (std::out_of_range& e) {
84915       {
84916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (std::exception& e) {
84919       {
84920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84921       };
84922     } catch (Dali::DaliException e) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84925       };
84926     } catch (...) {
84927       {
84928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84929       };
84930     }
84931   }
84932
84933   jresult = (void *)result;
84934   return jresult;
84935 }
84936
84937
84938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84939   void * jresult ;
84940   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84941   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84942
84943   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84944   {
84945     try {
84946       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84947     } catch (std::out_of_range& e) {
84948       {
84949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (std::exception& e) {
84952       {
84953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84954       };
84955     } catch (Dali::DaliException e) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84958       };
84959     } catch (...) {
84960       {
84961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84962       };
84963     }
84964   }
84965
84966   jresult = (void *)result;
84967   return jresult;
84968 }
84969
84970
84971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84972   void * jresult ;
84973   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84974   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84975
84976   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84977   {
84978     try {
84979       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84980     } catch (std::out_of_range& e) {
84981       {
84982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84983       };
84984     } catch (std::exception& e) {
84985       {
84986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84987       };
84988     } catch (Dali::DaliException e) {
84989       {
84990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84991       };
84992     } catch (...) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84995       };
84996     }
84997   }
84998
84999   jresult = (void *)result;
85000   return jresult;
85001 }
85002
85003
85004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
85005   void * jresult ;
85006   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85007
85008   {
85009     try {
85010       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
85011     } catch (std::out_of_range& e) {
85012       {
85013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85014       };
85015     } catch (std::exception& e) {
85016       {
85017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (Dali::DaliException e) {
85020       {
85021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85022       };
85023     } catch (...) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85026       };
85027     }
85028   }
85029
85030   jresult = (void *)result;
85031   return jresult;
85032 }
85033
85034
85035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
85036   void * jresult ;
85037   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
85038   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85039
85040   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85041   if (!arg1) {
85042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85043     return 0;
85044   }
85045   {
85046     try {
85047       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = (void *)result;
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85073   void * jresult ;
85074   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85075   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85076   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85077
85078   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85079   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85080   if (!arg2) {
85081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85082     return 0;
85083   }
85084   {
85085     try {
85086       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85087     } catch (std::out_of_range& e) {
85088       {
85089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85090       };
85091     } catch (std::exception& e) {
85092       {
85093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85094       };
85095     } catch (Dali::DaliException e) {
85096       {
85097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85098       };
85099     } catch (...) {
85100       {
85101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85102       };
85103     }
85104   }
85105
85106   jresult = (void *)result;
85107   return jresult;
85108 }
85109
85110
85111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85112   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85113
85114   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85115   {
85116     try {
85117       delete arg1;
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85133       };
85134     }
85135   }
85136
85137 }
85138
85139
85140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85141   void * jresult ;
85142   Dali::Toolkit::PageFactory *arg1 = 0 ;
85143   Dali::Vector2 *arg2 = 0 ;
85144   Dali::Toolkit::PageTurnLandscapeView result;
85145
85146   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85147   if (!arg1) {
85148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85149     return 0;
85150   }
85151   arg2 = (Dali::Vector2 *)jarg2;
85152   if (!arg2) {
85153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85154     return 0;
85155   }
85156   {
85157     try {
85158       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85159     } catch (std::out_of_range& e) {
85160       {
85161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85162       };
85163     } catch (std::exception& e) {
85164       {
85165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85166       };
85167     } catch (Dali::DaliException e) {
85168       {
85169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85170       };
85171     } catch (...) {
85172       {
85173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85174       };
85175     }
85176   }
85177
85178   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85179   return jresult;
85180 }
85181
85182
85183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85184   void * jresult ;
85185   Dali::BaseHandle arg1 ;
85186   Dali::BaseHandle *argp1 ;
85187   Dali::Toolkit::PageTurnLandscapeView result;
85188
85189   argp1 = (Dali::BaseHandle *)jarg1;
85190   if (!argp1) {
85191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85192     return 0;
85193   }
85194   arg1 = *argp1;
85195   {
85196     try {
85197       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85198     } catch (std::out_of_range& e) {
85199       {
85200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85201       };
85202     } catch (std::exception& e) {
85203       {
85204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85205       };
85206     } catch (Dali::DaliException e) {
85207       {
85208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85209       };
85210     } catch (...) {
85211       {
85212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85213       };
85214     }
85215   }
85216
85217   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85218   return jresult;
85219 }
85220
85221
85222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85223   void * jresult ;
85224   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85225
85226   {
85227     try {
85228       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85229     } catch (std::out_of_range& e) {
85230       {
85231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85232       };
85233     } catch (std::exception& e) {
85234       {
85235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85236       };
85237     } catch (Dali::DaliException e) {
85238       {
85239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85240       };
85241     } catch (...) {
85242       {
85243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85244       };
85245     }
85246   }
85247
85248   jresult = (void *)result;
85249   return jresult;
85250 }
85251
85252
85253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85254   void * jresult ;
85255   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85256   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85257
85258   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85259   if (!arg1) {
85260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85261     return 0;
85262   }
85263   {
85264     try {
85265       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85266     } catch (std::out_of_range& e) {
85267       {
85268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85269       };
85270     } catch (std::exception& e) {
85271       {
85272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (Dali::DaliException e) {
85275       {
85276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85277       };
85278     } catch (...) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85281       };
85282     }
85283   }
85284
85285   jresult = (void *)result;
85286   return jresult;
85287 }
85288
85289
85290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85291   void * jresult ;
85292   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85293   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85294   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85295
85296   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85297   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85298   if (!arg2) {
85299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85300     return 0;
85301   }
85302   {
85303     try {
85304       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85305     } catch (std::out_of_range& e) {
85306       {
85307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85308       };
85309     } catch (std::exception& e) {
85310       {
85311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85312       };
85313     } catch (Dali::DaliException e) {
85314       {
85315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85316       };
85317     } catch (...) {
85318       {
85319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85320       };
85321     }
85322   }
85323
85324   jresult = (void *)result;
85325   return jresult;
85326 }
85327
85328
85329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85330   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85331
85332   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85333   {
85334     try {
85335       delete arg1;
85336     } catch (std::out_of_range& e) {
85337       {
85338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85339       };
85340     } catch (std::exception& e) {
85341       {
85342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85343       };
85344     } catch (Dali::DaliException e) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85347       };
85348     } catch (...) {
85349       {
85350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85351       };
85352     }
85353   }
85354
85355 }
85356
85357
85358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85359   void * jresult ;
85360   Dali::Toolkit::PageFactory *arg1 = 0 ;
85361   Dali::Vector2 *arg2 = 0 ;
85362   Dali::Toolkit::PageTurnPortraitView result;
85363
85364   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85365   if (!arg1) {
85366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85367     return 0;
85368   }
85369   arg2 = (Dali::Vector2 *)jarg2;
85370   if (!arg2) {
85371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85372     return 0;
85373   }
85374   {
85375     try {
85376       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85377     } catch (std::out_of_range& e) {
85378       {
85379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85380       };
85381     } catch (std::exception& e) {
85382       {
85383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (Dali::DaliException e) {
85386       {
85387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85388       };
85389     } catch (...) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85392       };
85393     }
85394   }
85395
85396   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85397   return jresult;
85398 }
85399
85400
85401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85402   void * jresult ;
85403   Dali::BaseHandle arg1 ;
85404   Dali::BaseHandle *argp1 ;
85405   Dali::Toolkit::PageTurnPortraitView result;
85406
85407   argp1 = (Dali::BaseHandle *)jarg1;
85408   if (!argp1) {
85409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85410     return 0;
85411   }
85412   arg1 = *argp1;
85413   {
85414     try {
85415       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85416     } catch (std::out_of_range& e) {
85417       {
85418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85419       };
85420     } catch (std::exception& e) {
85421       {
85422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85423       };
85424     } catch (Dali::DaliException e) {
85425       {
85426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85427       };
85428     } catch (...) {
85429       {
85430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85431       };
85432     }
85433   }
85434
85435   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85436   return jresult;
85437 }
85438
85439
85440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85441   int jresult ;
85442   int result;
85443
85444   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85445   jresult = (int)result;
85446   return jresult;
85447 }
85448
85449
85450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85451   int jresult ;
85452   int result;
85453
85454   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85455   jresult = (int)result;
85456   return jresult;
85457 }
85458
85459
85460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85461   int jresult ;
85462   int result;
85463
85464   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85465   jresult = (int)result;
85466   return jresult;
85467 }
85468
85469
85470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85471   void * jresult ;
85472   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85473
85474   {
85475     try {
85476       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85477     } catch (std::out_of_range& e) {
85478       {
85479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85480       };
85481     } catch (std::exception& e) {
85482       {
85483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85484       };
85485     } catch (Dali::DaliException e) {
85486       {
85487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85488       };
85489     } catch (...) {
85490       {
85491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85492       };
85493     }
85494   }
85495
85496   jresult = (void *)result;
85497   return jresult;
85498 }
85499
85500
85501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85502   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85503
85504   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85505   {
85506     try {
85507       delete arg1;
85508     } catch (std::out_of_range& e) {
85509       {
85510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85511       };
85512     } catch (std::exception& e) {
85513       {
85514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85515       };
85516     } catch (Dali::DaliException e) {
85517       {
85518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85519       };
85520     } catch (...) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85523       };
85524     }
85525   }
85526
85527 }
85528
85529
85530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85531   void * jresult ;
85532   Dali::Toolkit::ToggleButton *result = 0 ;
85533
85534   {
85535     try {
85536       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85537     } catch (std::out_of_range& e) {
85538       {
85539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85540       };
85541     } catch (std::exception& e) {
85542       {
85543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85544       };
85545     } catch (Dali::DaliException e) {
85546       {
85547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85548       };
85549     } catch (...) {
85550       {
85551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85552       };
85553     }
85554   }
85555
85556   jresult = (void *)result;
85557   return jresult;
85558 }
85559
85560
85561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85562   void * jresult ;
85563   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85564   Dali::Toolkit::ToggleButton *result = 0 ;
85565
85566   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85567   if (!arg1) {
85568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85569     return 0;
85570   }
85571   {
85572     try {
85573       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85574     } catch (std::out_of_range& e) {
85575       {
85576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85577       };
85578     } catch (std::exception& e) {
85579       {
85580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85581       };
85582     } catch (Dali::DaliException e) {
85583       {
85584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85585       };
85586     } catch (...) {
85587       {
85588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85589       };
85590     }
85591   }
85592
85593   jresult = (void *)result;
85594   return jresult;
85595 }
85596
85597
85598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85599   void * jresult ;
85600   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85601   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85602   Dali::Toolkit::ToggleButton *result = 0 ;
85603
85604   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85605   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85606   if (!arg2) {
85607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85608     return 0;
85609   }
85610   {
85611     try {
85612       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85613     } catch (std::out_of_range& e) {
85614       {
85615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85616       };
85617     } catch (std::exception& e) {
85618       {
85619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (Dali::DaliException e) {
85622       {
85623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85624       };
85625     } catch (...) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85628       };
85629     }
85630   }
85631
85632   jresult = (void *)result;
85633   return jresult;
85634 }
85635
85636
85637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85638   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85639
85640   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85641   {
85642     try {
85643       delete arg1;
85644     } catch (std::out_of_range& e) {
85645       {
85646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85647       };
85648     } catch (std::exception& e) {
85649       {
85650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85651       };
85652     } catch (Dali::DaliException e) {
85653       {
85654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85655       };
85656     } catch (...) {
85657       {
85658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85659       };
85660     }
85661   }
85662
85663 }
85664
85665
85666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85667   void * jresult ;
85668   Dali::Toolkit::ToggleButton result;
85669
85670   {
85671     try {
85672       result = Dali::Toolkit::ToggleButton::New();
85673     } catch (std::out_of_range& e) {
85674       {
85675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85676       };
85677     } catch (std::exception& e) {
85678       {
85679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85680       };
85681     } catch (Dali::DaliException e) {
85682       {
85683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85684       };
85685     } catch (...) {
85686       {
85687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85688       };
85689     }
85690   }
85691
85692   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85693   return jresult;
85694 }
85695
85696
85697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85698   void * jresult ;
85699   Dali::BaseHandle arg1 ;
85700   Dali::BaseHandle *argp1 ;
85701   Dali::Toolkit::ToggleButton result;
85702
85703   argp1 = (Dali::BaseHandle *)jarg1;
85704   if (!argp1) {
85705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85706     return 0;
85707   }
85708   arg1 = *argp1;
85709   {
85710     try {
85711       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85712     } catch (std::out_of_range& e) {
85713       {
85714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85715       };
85716     } catch (std::exception& e) {
85717       {
85718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (Dali::DaliException e) {
85721       {
85722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85723       };
85724     } catch (...) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85727       };
85728     }
85729   }
85730
85731   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85732   return jresult;
85733 }
85734
85735
85736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85737   void * jresult ;
85738   Dali::Toolkit::Visual::Base *result = 0 ;
85739
85740   {
85741     try {
85742       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85743     } catch (std::out_of_range& e) {
85744       {
85745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85746       };
85747     } catch (std::exception& e) {
85748       {
85749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85750       };
85751     } catch (Dali::DaliException e) {
85752       {
85753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85754       };
85755     } catch (...) {
85756       {
85757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85758       };
85759     }
85760   }
85761
85762   jresult = (void *)result;
85763   return jresult;
85764 }
85765
85766
85767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85768   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85769
85770   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85771   {
85772     try {
85773       delete arg1;
85774     } catch (std::out_of_range& e) {
85775       {
85776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85777       };
85778     } catch (std::exception& e) {
85779       {
85780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85781       };
85782     } catch (Dali::DaliException e) {
85783       {
85784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85785       };
85786     } catch (...) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85789       };
85790     }
85791   }
85792
85793 }
85794
85795
85796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85797   void * jresult ;
85798   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85799   Dali::Toolkit::Visual::Base *result = 0 ;
85800
85801   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85802   if (!arg1) {
85803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85804     return 0;
85805   }
85806   {
85807     try {
85808       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85809     } catch (std::out_of_range& e) {
85810       {
85811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85812       };
85813     } catch (std::exception& e) {
85814       {
85815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85816       };
85817     } catch (Dali::DaliException e) {
85818       {
85819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85820       };
85821     } catch (...) {
85822       {
85823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85824       };
85825     }
85826   }
85827
85828   jresult = (void *)result;
85829   return jresult;
85830 }
85831
85832
85833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85834   void * jresult ;
85835   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85836   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85837   Dali::Toolkit::Visual::Base *result = 0 ;
85838
85839   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85840   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85841   if (!arg2) {
85842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85843     return 0;
85844   }
85845   {
85846     try {
85847       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (Dali::DaliException e) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85859       };
85860     } catch (...) {
85861       {
85862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85863       };
85864     }
85865   }
85866
85867   jresult = (void *)result;
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85873   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85874   std::string *arg2 = 0 ;
85875
85876   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85877   if (!jarg2) {
85878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85879     return ;
85880   }
85881   std::string arg2_str(jarg2);
85882   arg2 = &arg2_str;
85883   {
85884     try {
85885       (arg1)->SetName((std::string const &)*arg2);
85886     } catch (std::out_of_range& e) {
85887       {
85888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85889       };
85890     } catch (std::exception& e) {
85891       {
85892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85893       };
85894     } catch (Dali::DaliException e) {
85895       {
85896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85897       };
85898     } catch (...) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85901       };
85902     }
85903   }
85904
85905
85906   //argout typemap for const std::string&
85907
85908 }
85909
85910
85911 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85912   char * jresult ;
85913   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85914   std::string *result = 0 ;
85915
85916   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85917   {
85918     try {
85919       result = (std::string *) &(arg1)->GetName();
85920     } catch (std::out_of_range& e) {
85921       {
85922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (std::exception& e) {
85925       {
85926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85927       };
85928     } catch (Dali::DaliException e) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85931       };
85932     } catch (...) {
85933       {
85934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85935       };
85936     }
85937   }
85938
85939   jresult = SWIG_csharp_string_callback(result->c_str());
85940   return jresult;
85941 }
85942
85943
85944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85945   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85946   Dali::Property::Map *arg2 = 0 ;
85947   Dali::Size arg3 ;
85948   Dali::Size *argp3 ;
85949
85950   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85951   arg2 = (Dali::Property::Map *)jarg2;
85952   if (!arg2) {
85953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85954     return ;
85955   }
85956   argp3 = (Dali::Size *)jarg3;
85957   if (!argp3) {
85958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85959     return ;
85960   }
85961   arg3 = *argp3;
85962   {
85963     try {
85964       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85965     } catch (std::out_of_range& e) {
85966       {
85967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85968       };
85969     } catch (std::exception& e) {
85970       {
85971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85972       };
85973     } catch (Dali::DaliException e) {
85974       {
85975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85980       };
85981     }
85982   }
85983
85984 }
85985
85986
85987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85988   float jresult ;
85989   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85990   float arg2 ;
85991   float result;
85992
85993   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85994   arg2 = (float)jarg2;
85995   {
85996     try {
85997       result = (float)(arg1)->GetHeightForWidth(arg2);
85998     } catch (std::out_of_range& e) {
85999       {
86000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (std::exception& e) {
86003       {
86004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86005       };
86006     } catch (Dali::DaliException e) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86009       };
86010     } catch (...) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86013       };
86014     }
86015   }
86016
86017   jresult = result;
86018   return jresult;
86019 }
86020
86021
86022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
86023   float jresult ;
86024   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86025   float arg2 ;
86026   float result;
86027
86028   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86029   arg2 = (float)jarg2;
86030   {
86031     try {
86032       result = (float)(arg1)->GetWidthForHeight(arg2);
86033     } catch (std::out_of_range& e) {
86034       {
86035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86036       };
86037     } catch (std::exception& e) {
86038       {
86039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86040       };
86041     } catch (Dali::DaliException e) {
86042       {
86043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86044       };
86045     } catch (...) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86048       };
86049     }
86050   }
86051
86052   jresult = result;
86053   return jresult;
86054 }
86055
86056
86057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
86058   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86059   Dali::Vector2 *arg2 = 0 ;
86060
86061   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86062   arg2 = (Dali::Vector2 *)jarg2;
86063   if (!arg2) {
86064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
86065     return ;
86066   }
86067   {
86068     try {
86069       (arg1)->GetNaturalSize(*arg2);
86070     } catch (std::out_of_range& e) {
86071       {
86072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86073       };
86074     } catch (std::exception& e) {
86075       {
86076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86077       };
86078     } catch (Dali::DaliException e) {
86079       {
86080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86081       };
86082     } catch (...) {
86083       {
86084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86085       };
86086     }
86087   }
86088
86089 }
86090
86091
86092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86093   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86094   float arg2 ;
86095
86096   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86097   arg2 = (int)jarg2;
86098   {
86099     try {
86100       (arg1)->SetDepthIndex(arg2);
86101     } catch (std::out_of_range& e) {
86102       {
86103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86104       };
86105     } catch (std::exception& e) {
86106       {
86107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86108       };
86109     } catch (Dali::DaliException e) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86112       };
86113     } catch (...) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86116       };
86117     }
86118   }
86119
86120 }
86121
86122
86123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86124   int jresult ;
86125   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86126   int result;
86127
86128   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86129   {
86130     try {
86131       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86132     } catch (std::out_of_range& e) {
86133       {
86134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86135       };
86136     } catch (std::exception& e) {
86137       {
86138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86139       };
86140     } catch (Dali::DaliException e) {
86141       {
86142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86143       };
86144     } catch (...) {
86145       {
86146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86147       };
86148     }
86149   }
86150
86151   jresult = result;
86152   return jresult;
86153 }
86154
86155
86156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86157   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86158   Dali::Property::Map *arg2 = 0 ;
86159
86160   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86161   arg2 = (Dali::Property::Map *)jarg2;
86162   if (!arg2) {
86163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86164     return ;
86165   }
86166   {
86167     try {
86168       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86169     } catch (std::out_of_range& e) {
86170       {
86171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86172       };
86173     } catch (std::exception& e) {
86174       {
86175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86176       };
86177     } catch (Dali::DaliException e) {
86178       {
86179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86180       };
86181     } catch (...) {
86182       {
86183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86184       };
86185     }
86186   }
86187
86188 }
86189
86190
86191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86192   void * jresult ;
86193   Dali::Toolkit::VisualFactory result;
86194
86195   {
86196     try {
86197       result = Dali::Toolkit::VisualFactory::Get();
86198     } catch (std::out_of_range& e) {
86199       {
86200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86201       };
86202     } catch (std::exception& e) {
86203       {
86204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86205       };
86206     } catch (Dali::DaliException e) {
86207       {
86208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86209       };
86210     } catch (...) {
86211       {
86212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86213       };
86214     }
86215   }
86216
86217   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86218   return jresult;
86219 }
86220
86221
86222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86223   void * jresult ;
86224   Dali::Toolkit::VisualFactory *result = 0 ;
86225
86226   {
86227     try {
86228       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86229     } catch (std::out_of_range& e) {
86230       {
86231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86232       };
86233     } catch (std::exception& e) {
86234       {
86235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (Dali::DaliException e) {
86238       {
86239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86240       };
86241     } catch (...) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86244       };
86245     }
86246   }
86247
86248   jresult = (void *)result;
86249   return jresult;
86250 }
86251
86252
86253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86254   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86255
86256   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86257   {
86258     try {
86259       delete arg1;
86260     } catch (std::out_of_range& e) {
86261       {
86262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86263       };
86264     } catch (std::exception& e) {
86265       {
86266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86267       };
86268     } catch (Dali::DaliException e) {
86269       {
86270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86271       };
86272     } catch (...) {
86273       {
86274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86275       };
86276     }
86277   }
86278
86279 }
86280
86281
86282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86283   void * jresult ;
86284   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86285   Dali::Toolkit::VisualFactory *result = 0 ;
86286
86287   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86288   if (!arg1) {
86289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86290     return 0;
86291   }
86292   {
86293     try {
86294       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86295     } catch (std::out_of_range& e) {
86296       {
86297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (std::exception& e) {
86300       {
86301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86302       };
86303     } catch (Dali::DaliException e) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86306       };
86307     } catch (...) {
86308       {
86309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86310       };
86311     }
86312   }
86313
86314   jresult = (void *)result;
86315   return jresult;
86316 }
86317
86318
86319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86320   void * jresult ;
86321   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86322   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86323   Dali::Toolkit::VisualFactory *result = 0 ;
86324
86325   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86326   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86327   if (!arg2) {
86328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86329     return 0;
86330   }
86331   {
86332     try {
86333       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86334     } catch (std::out_of_range& e) {
86335       {
86336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86337       };
86338     } catch (std::exception& e) {
86339       {
86340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86341       };
86342     } catch (Dali::DaliException e) {
86343       {
86344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86345       };
86346     } catch (...) {
86347       {
86348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86349       };
86350     }
86351   }
86352
86353   jresult = (void *)result;
86354   return jresult;
86355 }
86356
86357
86358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86359   void * jresult ;
86360   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86361   Dali::Property::Map *arg2 = 0 ;
86362   Dali::Toolkit::Visual::Base result;
86363
86364   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86365   arg2 = (Dali::Property::Map *)jarg2;
86366   if (!arg2) {
86367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86368     return 0;
86369   }
86370   {
86371     try {
86372       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86373     } catch (std::out_of_range& e) {
86374       {
86375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86376       };
86377     } catch (std::exception& e) {
86378       {
86379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86380       };
86381     } catch (Dali::DaliException e) {
86382       {
86383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86384       };
86385     } catch (...) {
86386       {
86387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86388       };
86389     }
86390   }
86391
86392   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86393   return jresult;
86394 }
86395
86396
86397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86398   void * jresult ;
86399   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86400   std::string *arg2 = 0 ;
86401   Dali::ImageDimensions arg3 ;
86402   Dali::ImageDimensions *argp3 ;
86403   Dali::Toolkit::Visual::Base result;
86404
86405   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86406   if (!jarg2) {
86407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86408     return 0;
86409   }
86410   std::string arg2_str(jarg2);
86411   arg2 = &arg2_str;
86412   argp3 = (Dali::ImageDimensions *)jarg3;
86413   if (!argp3) {
86414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86415     return 0;
86416   }
86417   arg3 = *argp3;
86418   {
86419     try {
86420       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86421     } catch (std::out_of_range& e) {
86422       {
86423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (std::exception& e) {
86426       {
86427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86428       };
86429     } catch (Dali::DaliException e) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86432       };
86433     } catch (...) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86436       };
86437     }
86438   }
86439
86440   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86441
86442   //argout typemap for const std::string&
86443
86444   return jresult;
86445 }
86446
86447
86448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86449   void * jresult ;
86450   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86451
86452   {
86453     try {
86454       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86455     } catch (std::out_of_range& e) {
86456       {
86457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86458       };
86459     } catch (std::exception& e) {
86460       {
86461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86462       };
86463     } catch (Dali::DaliException e) {
86464       {
86465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86466       };
86467     } catch (...) {
86468       {
86469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86470       };
86471     }
86472   }
86473
86474   jresult = (void *)result;
86475   return jresult;
86476 }
86477
86478
86479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86480   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86481
86482   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86483   {
86484     try {
86485       delete arg1;
86486     } catch (std::out_of_range& e) {
86487       {
86488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86489       };
86490     } catch (std::exception& e) {
86491       {
86492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86493       };
86494     } catch (Dali::DaliException e) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86497       };
86498     } catch (...) {
86499       {
86500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86501       };
86502     }
86503   }
86504
86505 }
86506
86507
86508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86509   void * jresult ;
86510   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86511   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86512
86513   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86514   if (!arg1) {
86515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86516     return 0;
86517   }
86518   {
86519     try {
86520       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86528       };
86529     } catch (Dali::DaliException e) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86536       };
86537     }
86538   }
86539
86540   jresult = (void *)result;
86541   return jresult;
86542 }
86543
86544
86545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86546   void * jresult ;
86547   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86548   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86549   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86550
86551   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86552   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86553   if (!arg2) {
86554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86555     return 0;
86556   }
86557   {
86558     try {
86559       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86560     } catch (std::out_of_range& e) {
86561       {
86562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (std::exception& e) {
86565       {
86566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86567       };
86568     } catch (Dali::DaliException e) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86571       };
86572     } catch (...) {
86573       {
86574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86575       };
86576     }
86577   }
86578
86579   jresult = (void *)result;
86580   return jresult;
86581 }
86582
86583
86584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86585   void * jresult ;
86586   Dali::Toolkit::AsyncImageLoader result;
86587
86588   {
86589     try {
86590       result = Dali::Toolkit::AsyncImageLoader::New();
86591     } catch (std::out_of_range& e) {
86592       {
86593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (std::exception& e) {
86596       {
86597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (Dali::DaliException e) {
86600       {
86601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86602       };
86603     } catch (...) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86606       };
86607     }
86608   }
86609
86610   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86611   return jresult;
86612 }
86613
86614
86615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86616   void * jresult ;
86617   Dali::BaseHandle arg1 ;
86618   Dali::BaseHandle *argp1 ;
86619   Dali::Toolkit::AsyncImageLoader result;
86620
86621   argp1 = (Dali::BaseHandle *)jarg1;
86622   if (!argp1) {
86623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86624     return 0;
86625   }
86626   arg1 = *argp1;
86627   {
86628     try {
86629       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86630     } catch (std::out_of_range& e) {
86631       {
86632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86633       };
86634     } catch (std::exception& e) {
86635       {
86636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86637       };
86638     } catch (Dali::DaliException e) {
86639       {
86640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86641       };
86642     } catch (...) {
86643       {
86644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86645       };
86646     }
86647   }
86648
86649   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86650   return jresult;
86651 }
86652
86653
86654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86655   unsigned int jresult ;
86656   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86657   std::string *arg2 = 0 ;
86658   uint32_t result;
86659
86660   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86661   if (!jarg2) {
86662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86663     return 0;
86664   }
86665   std::string arg2_str(jarg2);
86666   arg2 = &arg2_str;
86667   {
86668     try {
86669       result = (arg1)->Load((std::string const &)*arg2);
86670     } catch (std::out_of_range& e) {
86671       {
86672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (std::exception& e) {
86675       {
86676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86677       };
86678     } catch (Dali::DaliException e) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86681       };
86682     } catch (...) {
86683       {
86684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86685       };
86686     }
86687   }
86688
86689   jresult = result;
86690
86691   //argout typemap for const std::string&
86692
86693   return jresult;
86694 }
86695
86696
86697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86698   unsigned int jresult ;
86699   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86700   std::string *arg2 = 0 ;
86701   Dali::ImageDimensions arg3 ;
86702   Dali::ImageDimensions *argp3 ;
86703   uint32_t result;
86704
86705   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86706   if (!jarg2) {
86707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86708     return 0;
86709   }
86710   std::string arg2_str(jarg2);
86711   arg2 = &arg2_str;
86712   argp3 = (Dali::ImageDimensions *)jarg3;
86713   if (!argp3) {
86714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86715     return 0;
86716   }
86717   arg3 = *argp3;
86718   {
86719     try {
86720       result = (arg1)->Load((std::string const &)*arg2,arg3);
86721     } catch (std::out_of_range& e) {
86722       {
86723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86724       };
86725     } catch (std::exception& e) {
86726       {
86727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86728       };
86729     } catch (Dali::DaliException e) {
86730       {
86731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86732       };
86733     } catch (...) {
86734       {
86735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86736       };
86737     }
86738   }
86739
86740   jresult = result;
86741
86742   //argout typemap for const std::string&
86743
86744   return jresult;
86745 }
86746
86747
86748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86749   unsigned int jresult ;
86750   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86751   std::string *arg2 = 0 ;
86752   Dali::ImageDimensions arg3 ;
86753   Dali::FittingMode::Type arg4 ;
86754   Dali::SamplingMode::Type arg5 ;
86755   bool arg6 ;
86756   Dali::ImageDimensions *argp3 ;
86757   uint32_t result;
86758
86759   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86760   if (!jarg2) {
86761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86762     return 0;
86763   }
86764   std::string arg2_str(jarg2);
86765   arg2 = &arg2_str;
86766   argp3 = (Dali::ImageDimensions *)jarg3;
86767   if (!argp3) {
86768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86769     return 0;
86770   }
86771   arg3 = *argp3;
86772   arg4 = (Dali::FittingMode::Type)jarg4;
86773   arg5 = (Dali::SamplingMode::Type)jarg5;
86774   arg6 = jarg6 ? true : false;
86775   {
86776     try {
86777       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86778     } catch (std::out_of_range& e) {
86779       {
86780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86781       };
86782     } catch (std::exception& e) {
86783       {
86784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86785       };
86786     } catch (Dali::DaliException e) {
86787       {
86788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86789       };
86790     } catch (...) {
86791       {
86792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86793       };
86794     }
86795   }
86796
86797   jresult = result;
86798
86799   //argout typemap for const std::string&
86800
86801   return jresult;
86802 }
86803
86804
86805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86806   unsigned int jresult ;
86807   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86808   uint32_t arg2 ;
86809   bool result;
86810
86811   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86812   arg2 = (uint32_t)jarg2;
86813   {
86814     try {
86815       result = (bool)(arg1)->Cancel(arg2);
86816     } catch (std::out_of_range& e) {
86817       {
86818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86819       };
86820     } catch (std::exception& e) {
86821       {
86822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86823       };
86824     } catch (Dali::DaliException e) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86827       };
86828     } catch (...) {
86829       {
86830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86831       };
86832     }
86833   }
86834
86835   jresult = result;
86836   return jresult;
86837 }
86838
86839
86840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86841   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86842
86843   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86844   {
86845     try {
86846       (arg1)->CancelAll();
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86854       };
86855     } catch (Dali::DaliException e) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86858       };
86859     } catch (...) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86862       };
86863     }
86864   }
86865
86866 }
86867
86868
86869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86870   void * jresult ;
86871   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86872   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86873
86874   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86875   {
86876     try {
86877       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86878     } catch (std::out_of_range& e) {
86879       {
86880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86881       };
86882     } catch (std::exception& e) {
86883       {
86884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86885       };
86886     } catch (Dali::DaliException e) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86889       };
86890     } catch (...) {
86891       {
86892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86893       };
86894     }
86895   }
86896
86897   jresult = (void *)result;
86898   return jresult;
86899 }
86900
86901
86902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86903   void * jresult ;
86904   std::string *arg1 = 0 ;
86905   Dali::PixelData result;
86906
86907   if (!jarg1) {
86908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86909     return 0;
86910   }
86911   std::string arg1_str(jarg1);
86912   arg1 = &arg1_str;
86913   {
86914     try {
86915       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86916     } catch (std::out_of_range& e) {
86917       {
86918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86919       };
86920     } catch (std::exception& e) {
86921       {
86922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86923       };
86924     } catch (Dali::DaliException e) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86927       };
86928     } catch (...) {
86929       {
86930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86931       };
86932     }
86933   }
86934
86935   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86936
86937   //argout typemap for const std::string&
86938
86939   return jresult;
86940 }
86941
86942
86943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86944   void * jresult ;
86945   std::string *arg1 = 0 ;
86946   Dali::ImageDimensions arg2 ;
86947   Dali::ImageDimensions *argp2 ;
86948   Dali::PixelData result;
86949
86950   if (!jarg1) {
86951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86952     return 0;
86953   }
86954   std::string arg1_str(jarg1);
86955   arg1 = &arg1_str;
86956   argp2 = (Dali::ImageDimensions *)jarg2;
86957   if (!argp2) {
86958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86959     return 0;
86960   }
86961   arg2 = *argp2;
86962   {
86963     try {
86964       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86965     } catch (std::out_of_range& e) {
86966       {
86967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86968       };
86969     } catch (std::exception& e) {
86970       {
86971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (Dali::DaliException e) {
86974       {
86975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86976       };
86977     } catch (...) {
86978       {
86979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86980       };
86981     }
86982   }
86983
86984   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86985
86986   //argout typemap for const std::string&
86987
86988   return jresult;
86989 }
86990
86991
86992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86993   void * jresult ;
86994   std::string *arg1 = 0 ;
86995   Dali::ImageDimensions arg2 ;
86996   Dali::FittingMode::Type arg3 ;
86997   Dali::SamplingMode::Type arg4 ;
86998   bool arg5 ;
86999   Dali::ImageDimensions *argp2 ;
87000   Dali::PixelData result;
87001
87002   if (!jarg1) {
87003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87004     return 0;
87005   }
87006   std::string arg1_str(jarg1);
87007   arg1 = &arg1_str;
87008   argp2 = (Dali::ImageDimensions *)jarg2;
87009   if (!argp2) {
87010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87011     return 0;
87012   }
87013   arg2 = *argp2;
87014   arg3 = (Dali::FittingMode::Type)jarg3;
87015   arg4 = (Dali::SamplingMode::Type)jarg4;
87016   arg5 = jarg5 ? true : false;
87017   {
87018     try {
87019       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
87020     } catch (std::out_of_range& e) {
87021       {
87022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87023       };
87024     } catch (std::exception& e) {
87025       {
87026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87027       };
87028     } catch (Dali::DaliException e) {
87029       {
87030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87031       };
87032     } catch (...) {
87033       {
87034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87035       };
87036     }
87037   }
87038
87039   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87040
87041   //argout typemap for const std::string&
87042
87043   return jresult;
87044 }
87045
87046
87047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
87048   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87049
87050   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87051   {
87052     try {
87053       delete arg1;
87054     } catch (std::out_of_range& e) {
87055       {
87056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87057       };
87058     } catch (std::exception& e) {
87059       {
87060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87061       };
87062     } catch (Dali::DaliException e) {
87063       {
87064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87065       };
87066     } catch (...) {
87067       {
87068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87069       };
87070     }
87071   }
87072
87073 }
87074
87075
87076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87077   void * jresult ;
87078   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87079   Dali::Actor arg2 ;
87080   Dali::Actor arg3 ;
87081   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87082   Dali::Actor *argp2 ;
87083   Dali::Actor *argp3 ;
87084   Dali::Actor result;
87085
87086   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87087   argp2 = (Dali::Actor *)jarg2;
87088   if (!argp2) {
87089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87090     return 0;
87091   }
87092   arg2 = *argp2;
87093   argp3 = (Dali::Actor *)jarg3;
87094   if (!argp3) {
87095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87096     return 0;
87097   }
87098   arg3 = *argp3;
87099   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87100   {
87101     try {
87102       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87103     } catch (std::out_of_range& e) {
87104       {
87105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (std::exception& e) {
87108       {
87109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87110       };
87111     } catch (Dali::DaliException e) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87114       };
87115     } catch (...) {
87116       {
87117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87118       };
87119     }
87120   }
87121
87122   jresult = new Dali::Actor((const Dali::Actor &)result);
87123   return jresult;
87124 }
87125
87126
87127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87128   void * jresult ;
87129   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87130
87131   {
87132     try {
87133       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87134     } catch (std::out_of_range& e) {
87135       {
87136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87137       };
87138     } catch (std::exception& e) {
87139       {
87140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87141       };
87142     } catch (Dali::DaliException e) {
87143       {
87144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87145       };
87146     } catch (...) {
87147       {
87148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87149       };
87150     }
87151   }
87152
87153   jresult = (void *)result;
87154   return jresult;
87155 }
87156
87157
87158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
87159   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
87160   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87161   if (director) {
87162     director->swig_connect_director(callback0);
87163   }
87164 }
87165
87166
87167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
87168   void * jresult ;
87169   Dali::FrameCallbackInterface *result = 0 ;
87170
87171   {
87172     try {
87173       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
87174     } catch (std::out_of_range& e) {
87175       {
87176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87177       };
87178     } catch (std::exception& e) {
87179       {
87180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87181       };
87182     } catch (Dali::DaliException e) {
87183       {
87184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87185       };
87186     } catch (...) {
87187       {
87188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87189       };
87190     }
87191   }
87192
87193   jresult = (void *)result;
87194   return jresult;
87195 }
87196
87197 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
87198   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87199   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87200   return proxy->GetPosition(id, *vector3);
87201 }
87202
87203 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
87204   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87205   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87206   return proxy->SetPosition(id, *vector3);
87207 }
87208
87209 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
87210   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87211   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
87212   return proxy->BakePosition(id, *vector3);
87213 }
87214
87215 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
87216   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87217   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87218   return proxy->GetSize(id, *vector3);
87219 }
87220
87221 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
87222   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87223   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87224   return proxy->SetSize(id, *vector3);
87225 }
87226 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
87227   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87228   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
87229   return proxy->BakeSize(id, *vector3);
87230 }
87231
87232 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
87233   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87234   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
87235   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
87236   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
87237 }
87238
87239 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
87240   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87241   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87242   return proxy->GetScale(id,* vector3);
87243 }
87244
87245 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87246   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87247   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87248   return proxy->SetScale(id, *vector3);
87249 }
87250
87251 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87252   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87253   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87254   return proxy->BakeScale(id, *vector3);
87255 }
87256
87257 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87258   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87259   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87260   return proxy->GetColor(id, *vector4);
87261 }
87262
87263 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87264   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87265   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87266   return proxy->SetColor(id, *vector4);
87267 }
87268
87269 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87270   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87271   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87272   return proxy->BakeColor(id, *vector4);
87273 }
87274
87275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87276   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87277   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87278
87279   Dali::Stage *arg1 = (Dali::Stage *) 0;
87280   Dali::Actor *arg3 = 0;
87281
87282   arg1 = (Dali::Stage *)jarg1;
87283   arg3 = (Dali::Actor *)jarg3;
87284
87285   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87286   return;
87287 }
87288
87289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87290
87291   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87292   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87293
87294   Dali::Stage *arg1 = (Dali::Stage *) 0;
87295
87296   arg1 = (Dali::Stage *)jarg1;
87297
87298   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87299   return;
87300 }
87301
87302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87303   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87304   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87305   if (director) {
87306     director->swig_connect_director(callback0);
87307   }
87308 }
87309
87310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87311   KeyboardFocusManager arg1 ;
87312   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87313   KeyboardFocusManager *argp1 ;
87314
87315   argp1 = (KeyboardFocusManager *)jarg1;
87316   if (!argp1) {
87317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87318     return ;
87319   }
87320   arg1 = *argp1;
87321   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87322   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87323   {
87324     try {
87325       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87326     } catch (std::out_of_range& e) {
87327       {
87328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87329       };
87330     } catch (std::exception& e) {
87331       {
87332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87333       };
87334     } catch (Dali::DaliException e) {
87335       {
87336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87337       };
87338     } catch (...) {
87339       {
87340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87341       };
87342     }
87343   }
87344
87345 }
87346
87347
87348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87349   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87350
87351   arg1 = (std::vector< unsigned int > *)jarg1;
87352   {
87353     try {
87354       (arg1)->clear();
87355     } catch (std::out_of_range& e) {
87356       {
87357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87358       };
87359     } catch (std::exception& e) {
87360       {
87361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87362       };
87363     } catch (Dali::DaliException e) {
87364       {
87365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87366       };
87367     } catch (...) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87370       };
87371     }
87372   }
87373
87374 }
87375
87376
87377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87378   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87379   unsigned int *arg2 = 0 ;
87380   unsigned int temp2 ;
87381
87382   arg1 = (std::vector< unsigned int > *)jarg1;
87383   temp2 = (unsigned int)jarg2;
87384   arg2 = &temp2;
87385   {
87386     try {
87387       (arg1)->push_back((unsigned int const &)*arg2);
87388     } catch (std::out_of_range& e) {
87389       {
87390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87391       };
87392     } catch (std::exception& e) {
87393       {
87394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87395       };
87396     } catch (Dali::DaliException e) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87399       };
87400     } catch (...) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87403       };
87404     }
87405   }
87406
87407 }
87408
87409
87410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87411   unsigned long jresult ;
87412   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87413   std::vector< unsigned int >::size_type result;
87414
87415   arg1 = (std::vector< unsigned int > *)jarg1;
87416   {
87417     try {
87418       result = ((std::vector< unsigned int > const *)arg1)->size();
87419     } catch (std::out_of_range& e) {
87420       {
87421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87422       };
87423     } catch (std::exception& e) {
87424       {
87425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (Dali::DaliException e) {
87428       {
87429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87430       };
87431     } catch (...) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87434       };
87435     }
87436   }
87437
87438   jresult = (unsigned long)result;
87439   return jresult;
87440 }
87441
87442
87443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87444   unsigned long jresult ;
87445   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87446   std::vector< unsigned int >::size_type result;
87447
87448   arg1 = (std::vector< unsigned int > *)jarg1;
87449   {
87450     try {
87451       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87452     } catch (std::out_of_range& e) {
87453       {
87454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87455       };
87456     } catch (std::exception& e) {
87457       {
87458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87459       };
87460     } catch (Dali::DaliException e) {
87461       {
87462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87463       };
87464     } catch (...) {
87465       {
87466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87467       };
87468     }
87469   }
87470
87471   jresult = (unsigned long)result;
87472   return jresult;
87473 }
87474
87475
87476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87477   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87478   std::vector< unsigned int >::size_type arg2 ;
87479
87480   arg1 = (std::vector< unsigned int > *)jarg1;
87481   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87482   {
87483     try {
87484       (arg1)->reserve(arg2);
87485     } catch (std::out_of_range& e) {
87486       {
87487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87488       };
87489     } catch (std::exception& e) {
87490       {
87491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87492       };
87493     } catch (Dali::DaliException e) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87496       };
87497     } catch (...) {
87498       {
87499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87500       };
87501     }
87502   }
87503
87504 }
87505
87506
87507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87508   void * jresult ;
87509   std::vector< unsigned int > *result = 0 ;
87510
87511   {
87512     try {
87513       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87514     } catch (std::out_of_range& e) {
87515       {
87516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87517       };
87518     } catch (std::exception& e) {
87519       {
87520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87521       };
87522     } catch (Dali::DaliException e) {
87523       {
87524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87529       };
87530     }
87531   }
87532
87533   jresult = (void *)result;
87534   return jresult;
87535 }
87536
87537
87538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87539   void * jresult ;
87540   std::vector< unsigned int > *arg1 = 0 ;
87541   std::vector< unsigned int > *result = 0 ;
87542
87543   arg1 = (std::vector< unsigned int > *)jarg1;
87544   if (!arg1) {
87545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87546     return 0;
87547   }
87548   {
87549     try {
87550       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87551     } catch (std::out_of_range& e) {
87552       {
87553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87554       };
87555     } catch (std::exception& e) {
87556       {
87557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87558       };
87559     } catch (Dali::DaliException e) {
87560       {
87561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87562       };
87563     } catch (...) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87566       };
87567     }
87568   }
87569
87570   jresult = (void *)result;
87571   return jresult;
87572 }
87573
87574
87575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87576   void * jresult ;
87577   int arg1 ;
87578   std::vector< unsigned int > *result = 0 ;
87579
87580   arg1 = (int)jarg1;
87581   {
87582     try {
87583       try {
87584         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87585       }
87586       catch(std::out_of_range &_e) {
87587         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87588         return 0;
87589       }
87590
87591     } catch (std::out_of_range& e) {
87592       {
87593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87594       };
87595     } catch (std::exception& e) {
87596       {
87597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87598       };
87599     } catch (Dali::DaliException e) {
87600       {
87601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87602       };
87603     } catch (...) {
87604       {
87605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87606       };
87607     }
87608   }
87609
87610   jresult = (void *)result;
87611   return jresult;
87612 }
87613
87614
87615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87616   unsigned int jresult ;
87617   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87618   int arg2 ;
87619   unsigned int result;
87620
87621   arg1 = (std::vector< unsigned int > *)jarg1;
87622   arg2 = (int)jarg2;
87623   {
87624     try {
87625       try {
87626         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87627       }
87628       catch(std::out_of_range &_e) {
87629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87630         return 0;
87631       }
87632
87633     } catch (std::out_of_range& e) {
87634       {
87635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87636       };
87637     } catch (std::exception& e) {
87638       {
87639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87640       };
87641     } catch (Dali::DaliException e) {
87642       {
87643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87644       };
87645     } catch (...) {
87646       {
87647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87648       };
87649     }
87650   }
87651
87652   jresult = result;
87653   return jresult;
87654 }
87655
87656
87657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87658   unsigned int jresult ;
87659   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87660   int arg2 ;
87661   unsigned int *result = 0 ;
87662
87663   arg1 = (std::vector< unsigned int > *)jarg1;
87664   arg2 = (int)jarg2;
87665   {
87666     try {
87667       try {
87668         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87669       }
87670       catch(std::out_of_range &_e) {
87671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87672         return 0;
87673       }
87674
87675     } catch (std::out_of_range& e) {
87676       {
87677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87678       };
87679     } catch (std::exception& e) {
87680       {
87681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87682       };
87683     } catch (Dali::DaliException e) {
87684       {
87685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87686       };
87687     } catch (...) {
87688       {
87689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87690       };
87691     }
87692   }
87693
87694   jresult = *result;
87695   return jresult;
87696 }
87697
87698
87699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87700   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87701   int arg2 ;
87702   unsigned int *arg3 = 0 ;
87703   unsigned int temp3 ;
87704
87705   arg1 = (std::vector< unsigned int > *)jarg1;
87706   arg2 = (int)jarg2;
87707   temp3 = (unsigned int)jarg3;
87708   arg3 = &temp3;
87709   {
87710     try {
87711       try {
87712         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87713       }
87714       catch(std::out_of_range &_e) {
87715         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87716         return ;
87717       }
87718
87719     } catch (std::out_of_range& e) {
87720       {
87721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87722       };
87723     } catch (std::exception& e) {
87724       {
87725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87726       };
87727     } catch (Dali::DaliException e) {
87728       {
87729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87730       };
87731     } catch (...) {
87732       {
87733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87734       };
87735     }
87736   }
87737
87738 }
87739
87740
87741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87742   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87743   std::vector< unsigned int > *arg2 = 0 ;
87744
87745   arg1 = (std::vector< unsigned int > *)jarg1;
87746   arg2 = (std::vector< unsigned int > *)jarg2;
87747   if (!arg2) {
87748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87749     return ;
87750   }
87751   {
87752     try {
87753       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (Dali::DaliException e) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87765       };
87766     } catch (...) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87769       };
87770     }
87771   }
87772
87773 }
87774
87775
87776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87777   void * jresult ;
87778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87779   int arg2 ;
87780   int arg3 ;
87781   std::vector< unsigned int > *result = 0 ;
87782
87783   arg1 = (std::vector< unsigned int > *)jarg1;
87784   arg2 = (int)jarg2;
87785   arg3 = (int)jarg3;
87786   {
87787     try {
87788       try {
87789         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87790       }
87791       catch(std::out_of_range &_e) {
87792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87793         return 0;
87794       }
87795       catch(std::invalid_argument &_e) {
87796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87797         return 0;
87798       }
87799
87800     } catch (std::out_of_range& e) {
87801       {
87802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87803       };
87804     } catch (std::exception& e) {
87805       {
87806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87807       };
87808     } catch (Dali::DaliException e) {
87809       {
87810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87811       };
87812     } catch (...) {
87813       {
87814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87815       };
87816     }
87817   }
87818
87819   jresult = (void *)result;
87820   return jresult;
87821 }
87822
87823
87824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87825   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87826   int arg2 ;
87827   unsigned int *arg3 = 0 ;
87828   unsigned int temp3 ;
87829
87830   arg1 = (std::vector< unsigned int > *)jarg1;
87831   arg2 = (int)jarg2;
87832   temp3 = (unsigned int)jarg3;
87833   arg3 = &temp3;
87834   {
87835     try {
87836       try {
87837         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87838       }
87839       catch(std::out_of_range &_e) {
87840         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87841         return ;
87842       }
87843
87844     } catch (std::out_of_range& e) {
87845       {
87846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87847       };
87848     } catch (std::exception& e) {
87849       {
87850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87851       };
87852     } catch (Dali::DaliException e) {
87853       {
87854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87855       };
87856     } catch (...) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87859       };
87860     }
87861   }
87862
87863 }
87864
87865
87866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87867   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87868   int arg2 ;
87869   std::vector< unsigned int > *arg3 = 0 ;
87870
87871   arg1 = (std::vector< unsigned int > *)jarg1;
87872   arg2 = (int)jarg2;
87873   arg3 = (std::vector< unsigned int > *)jarg3;
87874   if (!arg3) {
87875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87876     return ;
87877   }
87878   {
87879     try {
87880       try {
87881         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87882       }
87883       catch(std::out_of_range &_e) {
87884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87885         return ;
87886       }
87887
87888     } catch (std::out_of_range& e) {
87889       {
87890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87891       };
87892     } catch (std::exception& e) {
87893       {
87894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87895       };
87896     } catch (Dali::DaliException e) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87903       };
87904     }
87905   }
87906
87907 }
87908
87909
87910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87911   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87912   int arg2 ;
87913
87914   arg1 = (std::vector< unsigned int > *)jarg1;
87915   arg2 = (int)jarg2;
87916   {
87917     try {
87918       try {
87919         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87920       }
87921       catch(std::out_of_range &_e) {
87922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87923         return ;
87924       }
87925
87926     } catch (std::out_of_range& e) {
87927       {
87928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87929       };
87930     } catch (std::exception& e) {
87931       {
87932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87933       };
87934     } catch (Dali::DaliException e) {
87935       {
87936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87937       };
87938     } catch (...) {
87939       {
87940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87941       };
87942     }
87943   }
87944
87945 }
87946
87947
87948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87949   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87950   int arg2 ;
87951   int arg3 ;
87952
87953   arg1 = (std::vector< unsigned int > *)jarg1;
87954   arg2 = (int)jarg2;
87955   arg3 = (int)jarg3;
87956   {
87957     try {
87958       try {
87959         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87960       }
87961       catch(std::out_of_range &_e) {
87962         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87963         return ;
87964       }
87965       catch(std::invalid_argument &_e) {
87966         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87967         return ;
87968       }
87969
87970     } catch (std::out_of_range& e) {
87971       {
87972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87973       };
87974     } catch (std::exception& e) {
87975       {
87976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87977       };
87978     } catch (Dali::DaliException e) {
87979       {
87980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87981       };
87982     } catch (...) {
87983       {
87984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87985       };
87986     }
87987   }
87988
87989 }
87990
87991
87992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87993   void * jresult ;
87994   unsigned int *arg1 = 0 ;
87995   int arg2 ;
87996   unsigned int temp1 ;
87997   std::vector< unsigned int > *result = 0 ;
87998
87999   temp1 = (unsigned int)jarg1;
88000   arg1 = &temp1;
88001   arg2 = (int)jarg2;
88002   {
88003     try {
88004       try {
88005         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
88006       }
88007       catch(std::out_of_range &_e) {
88008         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88009         return 0;
88010       }
88011
88012     } catch (std::out_of_range& e) {
88013       {
88014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88015       };
88016     } catch (std::exception& e) {
88017       {
88018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88019       };
88020     } catch (Dali::DaliException e) {
88021       {
88022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88023       };
88024     } catch (...) {
88025       {
88026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88027       };
88028     }
88029   }
88030
88031   jresult = (void *)result;
88032   return jresult;
88033 }
88034
88035
88036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
88037   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88038
88039   arg1 = (std::vector< unsigned int > *)jarg1;
88040   {
88041     try {
88042       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
88043     } catch (std::out_of_range& e) {
88044       {
88045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88046       };
88047     } catch (std::exception& e) {
88048       {
88049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88050       };
88051     } catch (Dali::DaliException e) {
88052       {
88053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88054       };
88055     } catch (...) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88058       };
88059     }
88060   }
88061
88062 }
88063
88064
88065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88066   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88067   int arg2 ;
88068   int arg3 ;
88069
88070   arg1 = (std::vector< unsigned int > *)jarg1;
88071   arg2 = (int)jarg2;
88072   arg3 = (int)jarg3;
88073   {
88074     try {
88075       try {
88076         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88077       }
88078       catch(std::out_of_range &_e) {
88079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88080         return ;
88081       }
88082       catch(std::invalid_argument &_e) {
88083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88084         return ;
88085       }
88086
88087     } catch (std::out_of_range& e) {
88088       {
88089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88090       };
88091     } catch (std::exception& e) {
88092       {
88093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88094       };
88095     } catch (Dali::DaliException e) {
88096       {
88097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88098       };
88099     } catch (...) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88102       };
88103     }
88104   }
88105
88106 }
88107
88108
88109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88110   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88111   int arg2 ;
88112   std::vector< unsigned int > *arg3 = 0 ;
88113
88114   arg1 = (std::vector< unsigned int > *)jarg1;
88115   arg2 = (int)jarg2;
88116   arg3 = (std::vector< unsigned int > *)jarg3;
88117   if (!arg3) {
88118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88119     return ;
88120   }
88121   {
88122     try {
88123       try {
88124         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88125       }
88126       catch(std::out_of_range &_e) {
88127         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88128         return ;
88129       }
88130
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 unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88154   unsigned int jresult ;
88155   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88156   unsigned int *arg2 = 0 ;
88157   unsigned int temp2 ;
88158   bool result;
88159
88160   arg1 = (std::vector< unsigned int > *)jarg1;
88161   temp2 = (unsigned int)jarg2;
88162   arg2 = &temp2;
88163   {
88164     try {
88165       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88166     } catch (std::out_of_range& e) {
88167       {
88168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88169       };
88170     } catch (std::exception& e) {
88171       {
88172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88173       };
88174     } catch (Dali::DaliException e) {
88175       {
88176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88177       };
88178     } catch (...) {
88179       {
88180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88181       };
88182     }
88183   }
88184
88185   jresult = result;
88186   return jresult;
88187 }
88188
88189
88190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88191   int jresult ;
88192   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88193   unsigned int *arg2 = 0 ;
88194   unsigned int temp2 ;
88195   int result;
88196
88197   arg1 = (std::vector< unsigned int > *)jarg1;
88198   temp2 = (unsigned int)jarg2;
88199   arg2 = &temp2;
88200   {
88201     try {
88202       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88203     } catch (std::out_of_range& e) {
88204       {
88205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88206       };
88207     } catch (std::exception& e) {
88208       {
88209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88210       };
88211     } catch (Dali::DaliException e) {
88212       {
88213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88214       };
88215     } catch (...) {
88216       {
88217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88218       };
88219     }
88220   }
88221
88222   jresult = result;
88223   return jresult;
88224 }
88225
88226
88227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88228   int jresult ;
88229   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88230   unsigned int *arg2 = 0 ;
88231   unsigned int temp2 ;
88232   int result;
88233
88234   arg1 = (std::vector< unsigned int > *)jarg1;
88235   temp2 = (unsigned int)jarg2;
88236   arg2 = &temp2;
88237   {
88238     try {
88239       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
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 = result;
88260   return jresult;
88261 }
88262
88263
88264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88265   unsigned int jresult ;
88266   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88267   unsigned int *arg2 = 0 ;
88268   unsigned int temp2 ;
88269   bool result;
88270
88271   arg1 = (std::vector< unsigned int > *)jarg1;
88272   temp2 = (unsigned int)jarg2;
88273   arg2 = &temp2;
88274   {
88275     try {
88276       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88292       };
88293     }
88294   }
88295
88296   jresult = result;
88297   return jresult;
88298 }
88299
88300
88301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88302   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88303
88304   arg1 = (std::vector< unsigned int > *)jarg1;
88305   {
88306     try {
88307       delete arg1;
88308     } catch (std::out_of_range& e) {
88309       {
88310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88311       };
88312     } catch (std::exception& e) {
88313       {
88314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88315       };
88316     } catch (Dali::DaliException e) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88319       };
88320     } catch (...) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88323       };
88324     }
88325   }
88326
88327 }
88328
88329
88330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88331   void * jresult ;
88332   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88333
88334   {
88335     try {
88336       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88337     } catch (std::out_of_range& e) {
88338       {
88339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88340       };
88341     } catch (std::exception& e) {
88342       {
88343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88344       };
88345     } catch (Dali::DaliException e) {
88346       {
88347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88348       };
88349     } catch (...) {
88350       {
88351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88352       };
88353     }
88354   }
88355
88356   jresult = (void *)result;
88357   return jresult;
88358 }
88359
88360
88361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88362   void * jresult ;
88363   unsigned int arg1 ;
88364   Dali::Actor arg2 ;
88365   Dali::Actor *argp2 ;
88366   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88367
88368   arg1 = (unsigned int)jarg1;
88369   argp2 = (Dali::Actor *)jarg2;
88370   if (!argp2) {
88371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88372     return 0;
88373   }
88374   arg2 = *argp2;
88375   {
88376     try {
88377       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88378     } catch (std::out_of_range& e) {
88379       {
88380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88381       };
88382     } catch (std::exception& e) {
88383       {
88384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88385       };
88386     } catch (Dali::DaliException e) {
88387       {
88388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88389       };
88390     } catch (...) {
88391       {
88392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88393       };
88394     }
88395   }
88396
88397   jresult = (void *)result;
88398   return jresult;
88399 }
88400
88401
88402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88403   void * jresult ;
88404   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88405   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88406
88407   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88408   if (!arg1) {
88409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88410     return 0;
88411   }
88412   {
88413     try {
88414       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88415     } catch (std::out_of_range& e) {
88416       {
88417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88418       };
88419     } catch (std::exception& e) {
88420       {
88421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88422       };
88423     } catch (Dali::DaliException e) {
88424       {
88425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88426       };
88427     } catch (...) {
88428       {
88429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88430       };
88431     }
88432   }
88433
88434   jresult = (void *)result;
88435   return jresult;
88436 }
88437
88438
88439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88440   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88441   unsigned int arg2 ;
88442
88443   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88444   arg2 = (unsigned int)jarg2;
88445   if (arg1) (arg1)->first = arg2;
88446 }
88447
88448
88449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88450   unsigned int jresult ;
88451   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88452   unsigned int result;
88453
88454   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88455   result = (unsigned int) ((arg1)->first);
88456   jresult = result;
88457   return jresult;
88458 }
88459
88460
88461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88462   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88463   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88464
88465   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88466   arg2 = (Dali::Actor *)jarg2;
88467   if (arg1) (arg1)->second = *arg2;
88468 }
88469
88470
88471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88472   void * jresult ;
88473   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88474   Dali::Actor *result = 0 ;
88475
88476   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88477   result = (Dali::Actor *)& ((arg1)->second);
88478   jresult = (void *)result;
88479   return jresult;
88480 }
88481
88482
88483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88484   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88485
88486   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88487   {
88488     try {
88489       delete arg1;
88490     } catch (std::out_of_range& e) {
88491       {
88492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (std::exception& e) {
88495       {
88496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88497       };
88498     } catch (Dali::DaliException e) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88501       };
88502     } catch (...) {
88503       {
88504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88505       };
88506     }
88507   }
88508
88509 }
88510
88511
88512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88513   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88514
88515   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88516   {
88517     try {
88518       (arg1)->clear();
88519     } catch (std::out_of_range& e) {
88520       {
88521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88522       };
88523     } catch (std::exception& e) {
88524       {
88525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88526       };
88527     } catch (Dali::DaliException e) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88530       };
88531     } catch (...) {
88532       {
88533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88534       };
88535     }
88536   }
88537
88538 }
88539
88540
88541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88542   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88543   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88544
88545   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88546   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88547   if (!arg2) {
88548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88549     return ;
88550   }
88551   {
88552     try {
88553       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88554     } catch (std::out_of_range& e) {
88555       {
88556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88557       };
88558     } catch (std::exception& e) {
88559       {
88560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88561       };
88562     } catch (Dali::DaliException e) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88565       };
88566     } catch (...) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88569       };
88570     }
88571   }
88572
88573 }
88574
88575
88576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88577   unsigned long jresult ;
88578   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88579   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88580
88581   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88582   {
88583     try {
88584       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88585     } catch (std::out_of_range& e) {
88586       {
88587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88588       };
88589     } catch (std::exception& e) {
88590       {
88591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88592       };
88593     } catch (Dali::DaliException e) {
88594       {
88595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88596       };
88597     } catch (...) {
88598       {
88599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88600       };
88601     }
88602   }
88603
88604   jresult = (unsigned long)result;
88605   return jresult;
88606 }
88607
88608
88609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88610   unsigned long jresult ;
88611   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88612   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88613
88614   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88615   {
88616     try {
88617       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88618     } catch (std::out_of_range& e) {
88619       {
88620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88621       };
88622     } catch (std::exception& e) {
88623       {
88624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (Dali::DaliException e) {
88627       {
88628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88629       };
88630     } catch (...) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88633       };
88634     }
88635   }
88636
88637   jresult = (unsigned long)result;
88638   return jresult;
88639 }
88640
88641
88642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88643   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88644   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88645
88646   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88647   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88648   {
88649     try {
88650       (arg1)->reserve(arg2);
88651     } catch (std::out_of_range& e) {
88652       {
88653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88654       };
88655     } catch (std::exception& e) {
88656       {
88657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88658       };
88659     } catch (Dali::DaliException e) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88662       };
88663     } catch (...) {
88664       {
88665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88666       };
88667     }
88668   }
88669
88670 }
88671
88672
88673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88674   void * jresult ;
88675   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88676
88677   {
88678     try {
88679       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88680     } catch (std::out_of_range& e) {
88681       {
88682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88683       };
88684     } catch (std::exception& e) {
88685       {
88686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88687       };
88688     } catch (Dali::DaliException e) {
88689       {
88690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88691       };
88692     } catch (...) {
88693       {
88694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88695       };
88696     }
88697   }
88698
88699   jresult = (void *)result;
88700   return jresult;
88701 }
88702
88703
88704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88705   void * jresult ;
88706   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88707   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88708
88709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88710   if (!arg1) {
88711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88712     return 0;
88713   }
88714   {
88715     try {
88716       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);
88717     } catch (std::out_of_range& e) {
88718       {
88719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88720       };
88721     } catch (std::exception& e) {
88722       {
88723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88724       };
88725     } catch (Dali::DaliException e) {
88726       {
88727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88728       };
88729     } catch (...) {
88730       {
88731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88732       };
88733     }
88734   }
88735
88736   jresult = (void *)result;
88737   return jresult;
88738 }
88739
88740
88741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88742   void * jresult ;
88743   int arg1 ;
88744   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88745
88746   arg1 = (int)jarg1;
88747   {
88748     try {
88749       try {
88750         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);
88751       }
88752       catch(std::out_of_range &_e) {
88753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88754         return 0;
88755       }
88756
88757     } catch (std::out_of_range& e) {
88758       {
88759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88760       };
88761     } catch (std::exception& e) {
88762       {
88763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88764       };
88765     } catch (Dali::DaliException e) {
88766       {
88767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88768       };
88769     } catch (...) {
88770       {
88771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88772       };
88773     }
88774   }
88775
88776   jresult = (void *)result;
88777   return jresult;
88778 }
88779
88780
88781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88782   void * jresult ;
88783   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88784   int arg2 ;
88785   std::pair< unsigned int,Dali::Actor > result;
88786
88787   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88788   arg2 = (int)jarg2;
88789   {
88790     try {
88791       try {
88792         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88793       }
88794       catch(std::out_of_range &_e) {
88795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88796         return 0;
88797       }
88798
88799     } catch (std::out_of_range& e) {
88800       {
88801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88802       };
88803     } catch (std::exception& e) {
88804       {
88805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88806       };
88807     } catch (Dali::DaliException e) {
88808       {
88809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88810       };
88811     } catch (...) {
88812       {
88813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88814       };
88815     }
88816   }
88817
88818   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88819   return jresult;
88820 }
88821
88822
88823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88824   void * jresult ;
88825   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88826   int arg2 ;
88827   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88828
88829   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88830   arg2 = (int)jarg2;
88831   {
88832     try {
88833       try {
88834         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88835       }
88836       catch(std::out_of_range &_e) {
88837         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88838         return 0;
88839       }
88840
88841     } catch (std::out_of_range& e) {
88842       {
88843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88844       };
88845     } catch (std::exception& e) {
88846       {
88847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88848       };
88849     } catch (Dali::DaliException e) {
88850       {
88851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88852       };
88853     } catch (...) {
88854       {
88855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88856       };
88857     }
88858   }
88859
88860   jresult = (void *)result;
88861   return jresult;
88862 }
88863
88864
88865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88866   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88867   int arg2 ;
88868   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88869
88870   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88871   arg2 = (int)jarg2;
88872   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88873   if (!arg3) {
88874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88875     return ;
88876   }
88877   {
88878     try {
88879       try {
88880         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);
88881       }
88882       catch(std::out_of_range &_e) {
88883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88884         return ;
88885       }
88886
88887     } catch (std::out_of_range& e) {
88888       {
88889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88890       };
88891     } catch (std::exception& e) {
88892       {
88893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88894       };
88895     } catch (Dali::DaliException e) {
88896       {
88897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88898       };
88899     } catch (...) {
88900       {
88901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88902       };
88903     }
88904   }
88905
88906 }
88907
88908
88909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88910   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88911   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88912
88913   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88914   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88915   if (!arg2) {
88916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88917     return ;
88918   }
88919   {
88920     try {
88921       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);
88922     } catch (std::out_of_range& e) {
88923       {
88924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88925       };
88926     } catch (std::exception& e) {
88927       {
88928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88929       };
88930     } catch (Dali::DaliException e) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88933       };
88934     } catch (...) {
88935       {
88936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88937       };
88938     }
88939   }
88940
88941 }
88942
88943
88944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88945   void * jresult ;
88946   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88947   int arg2 ;
88948   int arg3 ;
88949   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88950
88951   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88952   arg2 = (int)jarg2;
88953   arg3 = (int)jarg3;
88954   {
88955     try {
88956       try {
88957         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);
88958       }
88959       catch(std::out_of_range &_e) {
88960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88961         return 0;
88962       }
88963       catch(std::invalid_argument &_e) {
88964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88965         return 0;
88966       }
88967
88968     } catch (std::out_of_range& e) {
88969       {
88970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88971       };
88972     } catch (std::exception& e) {
88973       {
88974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88975       };
88976     } catch (Dali::DaliException e) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88979       };
88980     } catch (...) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88983       };
88984     }
88985   }
88986
88987   jresult = (void *)result;
88988   return jresult;
88989 }
88990
88991
88992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88993   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88994   int arg2 ;
88995   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88996
88997   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88998   arg2 = (int)jarg2;
88999   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89000   if (!arg3) {
89001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89002     return ;
89003   }
89004   {
89005     try {
89006       try {
89007         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);
89008       }
89009       catch(std::out_of_range &_e) {
89010         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89011         return ;
89012       }
89013
89014     } catch (std::out_of_range& e) {
89015       {
89016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89017       };
89018     } catch (std::exception& e) {
89019       {
89020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89021       };
89022     } catch (Dali::DaliException e) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89025       };
89026     } catch (...) {
89027       {
89028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89029       };
89030     }
89031   }
89032
89033 }
89034
89035
89036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89037   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89038   int arg2 ;
89039   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89040
89041   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89042   arg2 = (int)jarg2;
89043   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89044   if (!arg3) {
89045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89046     return ;
89047   }
89048   {
89049     try {
89050       try {
89051         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);
89052       }
89053       catch(std::out_of_range &_e) {
89054         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89055         return ;
89056       }
89057
89058     } catch (std::out_of_range& e) {
89059       {
89060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89061       };
89062     } catch (std::exception& e) {
89063       {
89064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89065       };
89066     } catch (Dali::DaliException e) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89069       };
89070     } catch (...) {
89071       {
89072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89073       };
89074     }
89075   }
89076
89077 }
89078
89079
89080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89081   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89082   int arg2 ;
89083
89084   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89085   arg2 = (int)jarg2;
89086   {
89087     try {
89088       try {
89089         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89090       }
89091       catch(std::out_of_range &_e) {
89092         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89093         return ;
89094       }
89095
89096     } catch (std::out_of_range& e) {
89097       {
89098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89099       };
89100     } catch (std::exception& e) {
89101       {
89102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89103       };
89104     } catch (Dali::DaliException e) {
89105       {
89106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89107       };
89108     } catch (...) {
89109       {
89110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89111       };
89112     }
89113   }
89114
89115 }
89116
89117
89118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89119   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89120   int arg2 ;
89121   int arg3 ;
89122
89123   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89124   arg2 = (int)jarg2;
89125   arg3 = (int)jarg3;
89126   {
89127     try {
89128       try {
89129         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89130       }
89131       catch(std::out_of_range &_e) {
89132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89133         return ;
89134       }
89135       catch(std::invalid_argument &_e) {
89136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89137         return ;
89138       }
89139
89140     } catch (std::out_of_range& e) {
89141       {
89142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89143       };
89144     } catch (std::exception& e) {
89145       {
89146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89147       };
89148     } catch (Dali::DaliException e) {
89149       {
89150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89151       };
89152     } catch (...) {
89153       {
89154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89155       };
89156     }
89157   }
89158
89159 }
89160
89161
89162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89163   void * jresult ;
89164   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89165   int arg2 ;
89166   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89167
89168   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89169   if (!arg1) {
89170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89171     return 0;
89172   }
89173   arg2 = (int)jarg2;
89174   {
89175     try {
89176       try {
89177         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);
89178       }
89179       catch(std::out_of_range &_e) {
89180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89181         return 0;
89182       }
89183
89184     } catch (std::out_of_range& e) {
89185       {
89186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89187       };
89188     } catch (std::exception& e) {
89189       {
89190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89191       };
89192     } catch (Dali::DaliException e) {
89193       {
89194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89195       };
89196     } catch (...) {
89197       {
89198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89199       };
89200     }
89201   }
89202
89203   jresult = (void *)result;
89204   return jresult;
89205 }
89206
89207
89208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89209   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89210
89211   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89212   {
89213     try {
89214       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89215     } catch (std::out_of_range& e) {
89216       {
89217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89218       };
89219     } catch (std::exception& e) {
89220       {
89221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89222       };
89223     } catch (Dali::DaliException e) {
89224       {
89225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89226       };
89227     } catch (...) {
89228       {
89229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89230       };
89231     }
89232   }
89233
89234 }
89235
89236
89237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89238   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89239   int arg2 ;
89240   int arg3 ;
89241
89242   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89243   arg2 = (int)jarg2;
89244   arg3 = (int)jarg3;
89245   {
89246     try {
89247       try {
89248         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89249       }
89250       catch(std::out_of_range &_e) {
89251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89252         return ;
89253       }
89254       catch(std::invalid_argument &_e) {
89255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89256         return ;
89257       }
89258
89259     } catch (std::out_of_range& e) {
89260       {
89261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89262       };
89263     } catch (std::exception& e) {
89264       {
89265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89266       };
89267     } catch (Dali::DaliException e) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89270       };
89271     } catch (...) {
89272       {
89273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89274       };
89275     }
89276   }
89277
89278 }
89279
89280
89281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89282   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89283   int arg2 ;
89284   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89285
89286   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89287   arg2 = (int)jarg2;
89288   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89289   if (!arg3) {
89290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89291     return ;
89292   }
89293   {
89294     try {
89295       try {
89296         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);
89297       }
89298       catch(std::out_of_range &_e) {
89299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89300         return ;
89301       }
89302
89303     } catch (std::out_of_range& e) {
89304       {
89305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89306       };
89307     } catch (std::exception& e) {
89308       {
89309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89310       };
89311     } catch (Dali::DaliException e) {
89312       {
89313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89314       };
89315     } catch (...) {
89316       {
89317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89318       };
89319     }
89320   }
89321
89322 }
89323
89324
89325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89326   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89327
89328   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89329   {
89330     try {
89331       delete arg1;
89332     } catch (std::out_of_range& e) {
89333       {
89334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89335       };
89336     } catch (std::exception& e) {
89337       {
89338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89339       };
89340     } catch (Dali::DaliException e) {
89341       {
89342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89343       };
89344     } catch (...) {
89345       {
89346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89347       };
89348     }
89349   }
89350
89351 }
89352
89353
89354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89355   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89356
89357   arg1 = (std::vector< Dali::Actor > *)jarg1;
89358   {
89359     try {
89360       (arg1)->clear();
89361     } catch (std::out_of_range& e) {
89362       {
89363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89364       };
89365     } catch (std::exception& e) {
89366       {
89367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89368       };
89369     } catch (Dali::DaliException e) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89372       };
89373     } catch (...) {
89374       {
89375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89376       };
89377     }
89378   }
89379
89380 }
89381
89382
89383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89384   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89385   Dali::Actor *arg2 = 0 ;
89386
89387   arg1 = (std::vector< Dali::Actor > *)jarg1;
89388   arg2 = (Dali::Actor *)jarg2;
89389   if (!arg2) {
89390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89391     return ;
89392   }
89393   {
89394     try {
89395       (arg1)->push_back((Dali::Actor const &)*arg2);
89396     } catch (std::out_of_range& e) {
89397       {
89398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89399       };
89400     } catch (std::exception& e) {
89401       {
89402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89403       };
89404     } catch (Dali::DaliException e) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89407       };
89408     } catch (...) {
89409       {
89410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89411       };
89412     }
89413   }
89414
89415 }
89416
89417
89418 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89419   unsigned long jresult ;
89420   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89421   std::vector< Dali::Actor >::size_type result;
89422
89423   arg1 = (std::vector< Dali::Actor > *)jarg1;
89424   {
89425     try {
89426       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89427     } catch (std::out_of_range& e) {
89428       {
89429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89430       };
89431     } catch (std::exception& e) {
89432       {
89433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89434       };
89435     } catch (Dali::DaliException e) {
89436       {
89437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89438       };
89439     } catch (...) {
89440       {
89441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89442       };
89443     }
89444   }
89445
89446   jresult = (unsigned long)result;
89447   return jresult;
89448 }
89449
89450
89451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89452   unsigned long jresult ;
89453   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89454   std::vector< Dali::Actor >::size_type result;
89455
89456   arg1 = (std::vector< Dali::Actor > *)jarg1;
89457   {
89458     try {
89459       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89460     } catch (std::out_of_range& e) {
89461       {
89462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89463       };
89464     } catch (std::exception& e) {
89465       {
89466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89467       };
89468     } catch (Dali::DaliException e) {
89469       {
89470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89471       };
89472     } catch (...) {
89473       {
89474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89475       };
89476     }
89477   }
89478
89479   jresult = (unsigned long)result;
89480   return jresult;
89481 }
89482
89483
89484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89485   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89486   std::vector< Dali::Actor >::size_type arg2 ;
89487
89488   arg1 = (std::vector< Dali::Actor > *)jarg1;
89489   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89490   {
89491     try {
89492       (arg1)->reserve(arg2);
89493     } catch (std::out_of_range& e) {
89494       {
89495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89496       };
89497     } catch (std::exception& e) {
89498       {
89499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89500       };
89501     } catch (Dali::DaliException e) {
89502       {
89503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89504       };
89505     } catch (...) {
89506       {
89507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89508       };
89509     }
89510   }
89511
89512 }
89513
89514
89515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89516   void * jresult ;
89517   std::vector< Dali::Actor > *result = 0 ;
89518
89519   {
89520     try {
89521       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89522     } catch (std::out_of_range& e) {
89523       {
89524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89525       };
89526     } catch (std::exception& e) {
89527       {
89528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89529       };
89530     } catch (Dali::DaliException e) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89533       };
89534     } catch (...) {
89535       {
89536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89537       };
89538     }
89539   }
89540
89541   jresult = (void *)result;
89542   return jresult;
89543 }
89544
89545
89546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89547   void * jresult ;
89548   std::vector< Dali::Actor > *arg1 = 0 ;
89549   std::vector< Dali::Actor > *result = 0 ;
89550
89551   arg1 = (std::vector< Dali::Actor > *)jarg1;
89552   if (!arg1) {
89553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89554     return 0;
89555   }
89556   {
89557     try {
89558       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89559     } catch (std::out_of_range& e) {
89560       {
89561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89562       };
89563     } catch (std::exception& e) {
89564       {
89565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89566       };
89567     } catch (Dali::DaliException e) {
89568       {
89569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89570       };
89571     } catch (...) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89574       };
89575     }
89576   }
89577
89578   jresult = (void *)result;
89579   return jresult;
89580 }
89581
89582
89583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89584   void * jresult ;
89585   int arg1 ;
89586   std::vector< Dali::Actor > *result = 0 ;
89587
89588   arg1 = (int)jarg1;
89589   {
89590     try {
89591       try {
89592         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89593       }
89594       catch(std::out_of_range &_e) {
89595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89596         return 0;
89597       }
89598
89599     } catch (std::out_of_range& e) {
89600       {
89601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89602       };
89603     } catch (std::exception& e) {
89604       {
89605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89606       };
89607     } catch (Dali::DaliException e) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89610       };
89611     } catch (...) {
89612       {
89613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89614       };
89615     }
89616   }
89617
89618   jresult = (void *)result;
89619   return jresult;
89620 }
89621
89622
89623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89624   void * jresult ;
89625   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89626   int arg2 ;
89627   Dali::Actor result;
89628
89629   arg1 = (std::vector< Dali::Actor > *)jarg1;
89630   arg2 = (int)jarg2;
89631   {
89632     try {
89633       try {
89634         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89635       }
89636       catch(std::out_of_range &_e) {
89637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89638         return 0;
89639       }
89640
89641     } catch (std::out_of_range& e) {
89642       {
89643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89644       };
89645     } catch (std::exception& e) {
89646       {
89647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89648       };
89649     } catch (Dali::DaliException e) {
89650       {
89651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89652       };
89653     } catch (...) {
89654       {
89655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89656       };
89657     }
89658   }
89659
89660   jresult = new Dali::Actor((const Dali::Actor &)result);
89661   return jresult;
89662 }
89663
89664
89665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89666   void * jresult ;
89667   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89668   int arg2 ;
89669   Dali::Actor *result = 0 ;
89670
89671   arg1 = (std::vector< Dali::Actor > *)jarg1;
89672   arg2 = (int)jarg2;
89673   {
89674     try {
89675       try {
89676         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89677       }
89678       catch(std::out_of_range &_e) {
89679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89680         return 0;
89681       }
89682
89683     } catch (std::out_of_range& e) {
89684       {
89685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89686       };
89687     } catch (std::exception& e) {
89688       {
89689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89690       };
89691     } catch (Dali::DaliException e) {
89692       {
89693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89694       };
89695     } catch (...) {
89696       {
89697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89698       };
89699     }
89700   }
89701
89702   jresult = (void *)result;
89703   return jresult;
89704 }
89705
89706
89707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89708   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89709   int arg2 ;
89710   Dali::Actor *arg3 = 0 ;
89711
89712   arg1 = (std::vector< Dali::Actor > *)jarg1;
89713   arg2 = (int)jarg2;
89714   arg3 = (Dali::Actor *)jarg3;
89715   if (!arg3) {
89716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89717     return ;
89718   }
89719   {
89720     try {
89721       try {
89722         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89723       }
89724       catch(std::out_of_range &_e) {
89725         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89726         return ;
89727       }
89728
89729     } catch (std::out_of_range& e) {
89730       {
89731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89732       };
89733     } catch (std::exception& e) {
89734       {
89735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89736       };
89737     } catch (Dali::DaliException e) {
89738       {
89739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89740       };
89741     } catch (...) {
89742       {
89743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89744       };
89745     }
89746   }
89747
89748 }
89749
89750
89751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89752   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89753   std::vector< Dali::Actor > *arg2 = 0 ;
89754
89755   arg1 = (std::vector< Dali::Actor > *)jarg1;
89756   arg2 = (std::vector< Dali::Actor > *)jarg2;
89757   if (!arg2) {
89758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89759     return ;
89760   }
89761   {
89762     try {
89763       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89764     } catch (std::out_of_range& e) {
89765       {
89766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89767       };
89768     } catch (std::exception& e) {
89769       {
89770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89771       };
89772     } catch (Dali::DaliException e) {
89773       {
89774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89775       };
89776     } catch (...) {
89777       {
89778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89779       };
89780     }
89781   }
89782
89783 }
89784
89785
89786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89787   void * jresult ;
89788   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89789   int arg2 ;
89790   int arg3 ;
89791   std::vector< Dali::Actor > *result = 0 ;
89792
89793   arg1 = (std::vector< Dali::Actor > *)jarg1;
89794   arg2 = (int)jarg2;
89795   arg3 = (int)jarg3;
89796   {
89797     try {
89798       try {
89799         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89800       }
89801       catch(std::out_of_range &_e) {
89802         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89803         return 0;
89804       }
89805       catch(std::invalid_argument &_e) {
89806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89807         return 0;
89808       }
89809
89810     } catch (std::out_of_range& e) {
89811       {
89812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89813       };
89814     } catch (std::exception& e) {
89815       {
89816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89817       };
89818     } catch (Dali::DaliException e) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89821       };
89822     } catch (...) {
89823       {
89824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89825       };
89826     }
89827   }
89828
89829   jresult = (void *)result;
89830   return jresult;
89831 }
89832
89833
89834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89835   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89836   int arg2 ;
89837   Dali::Actor *arg3 = 0 ;
89838
89839   arg1 = (std::vector< Dali::Actor > *)jarg1;
89840   arg2 = (int)jarg2;
89841   arg3 = (Dali::Actor *)jarg3;
89842   if (!arg3) {
89843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89844     return ;
89845   }
89846   {
89847     try {
89848       try {
89849         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89850       }
89851       catch(std::out_of_range &_e) {
89852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89853         return ;
89854       }
89855
89856     } catch (std::out_of_range& e) {
89857       {
89858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89859       };
89860     } catch (std::exception& e) {
89861       {
89862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89863       };
89864     } catch (Dali::DaliException e) {
89865       {
89866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89867       };
89868     } catch (...) {
89869       {
89870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89871       };
89872     }
89873   }
89874
89875 }
89876
89877
89878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89879   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89880   int arg2 ;
89881   std::vector< Dali::Actor > *arg3 = 0 ;
89882
89883   arg1 = (std::vector< Dali::Actor > *)jarg1;
89884   arg2 = (int)jarg2;
89885   arg3 = (std::vector< Dali::Actor > *)jarg3;
89886   if (!arg3) {
89887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89888     return ;
89889   }
89890   {
89891     try {
89892       try {
89893         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89894       }
89895       catch(std::out_of_range &_e) {
89896         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89897         return ;
89898       }
89899
89900     } catch (std::out_of_range& e) {
89901       {
89902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89903       };
89904     } catch (std::exception& e) {
89905       {
89906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89907       };
89908     } catch (Dali::DaliException e) {
89909       {
89910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89911       };
89912     } catch (...) {
89913       {
89914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89915       };
89916     }
89917   }
89918
89919 }
89920
89921
89922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89923   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89924   int arg2 ;
89925
89926   arg1 = (std::vector< Dali::Actor > *)jarg1;
89927   arg2 = (int)jarg2;
89928   {
89929     try {
89930       try {
89931         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89932       }
89933       catch(std::out_of_range &_e) {
89934         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89935         return ;
89936       }
89937
89938     } catch (std::out_of_range& e) {
89939       {
89940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89941       };
89942     } catch (std::exception& e) {
89943       {
89944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89945       };
89946     } catch (Dali::DaliException e) {
89947       {
89948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89949       };
89950     } catch (...) {
89951       {
89952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89953       };
89954     }
89955   }
89956
89957 }
89958
89959
89960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89961   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89962   int arg2 ;
89963   int arg3 ;
89964
89965   arg1 = (std::vector< Dali::Actor > *)jarg1;
89966   arg2 = (int)jarg2;
89967   arg3 = (int)jarg3;
89968   {
89969     try {
89970       try {
89971         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89972       }
89973       catch(std::out_of_range &_e) {
89974         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89975         return ;
89976       }
89977       catch(std::invalid_argument &_e) {
89978         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89979         return ;
89980       }
89981
89982     } catch (std::out_of_range& e) {
89983       {
89984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89985       };
89986     } catch (std::exception& e) {
89987       {
89988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89989       };
89990     } catch (Dali::DaliException e) {
89991       {
89992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89993       };
89994     } catch (...) {
89995       {
89996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89997       };
89998     }
89999   }
90000
90001 }
90002
90003
90004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
90005   void * jresult ;
90006   Dali::Actor *arg1 = 0 ;
90007   int arg2 ;
90008   std::vector< Dali::Actor > *result = 0 ;
90009
90010   arg1 = (Dali::Actor *)jarg1;
90011   if (!arg1) {
90012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90013     return 0;
90014   }
90015   arg2 = (int)jarg2;
90016   {
90017     try {
90018       try {
90019         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
90020       }
90021       catch(std::out_of_range &_e) {
90022         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90023         return 0;
90024       }
90025
90026     } catch (std::out_of_range& e) {
90027       {
90028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90029       };
90030     } catch (std::exception& e) {
90031       {
90032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90033       };
90034     } catch (Dali::DaliException e) {
90035       {
90036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90037       };
90038     } catch (...) {
90039       {
90040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90041       };
90042     }
90043   }
90044
90045   jresult = (void *)result;
90046   return jresult;
90047 }
90048
90049
90050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
90051   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90052
90053   arg1 = (std::vector< Dali::Actor > *)jarg1;
90054   {
90055     try {
90056       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
90057     } catch (std::out_of_range& e) {
90058       {
90059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90060       };
90061     } catch (std::exception& e) {
90062       {
90063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90064       };
90065     } catch (Dali::DaliException e) {
90066       {
90067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90068       };
90069     } catch (...) {
90070       {
90071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90072       };
90073     }
90074   }
90075
90076 }
90077
90078
90079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90080   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90081   int arg2 ;
90082   int arg3 ;
90083
90084   arg1 = (std::vector< Dali::Actor > *)jarg1;
90085   arg2 = (int)jarg2;
90086   arg3 = (int)jarg3;
90087   {
90088     try {
90089       try {
90090         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90091       }
90092       catch(std::out_of_range &_e) {
90093         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90094         return ;
90095       }
90096       catch(std::invalid_argument &_e) {
90097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90098         return ;
90099       }
90100
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90108       };
90109     } catch (Dali::DaliException e) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90116       };
90117     }
90118   }
90119
90120 }
90121
90122
90123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90124   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90125   int arg2 ;
90126   std::vector< Dali::Actor > *arg3 = 0 ;
90127
90128   arg1 = (std::vector< Dali::Actor > *)jarg1;
90129   arg2 = (int)jarg2;
90130   arg3 = (std::vector< Dali::Actor > *)jarg3;
90131   if (!arg3) {
90132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90133     return ;
90134   }
90135   {
90136     try {
90137       try {
90138         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90139       }
90140       catch(std::out_of_range &_e) {
90141         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90142         return ;
90143       }
90144
90145     } catch (std::out_of_range& e) {
90146       {
90147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90148       };
90149     } catch (std::exception& e) {
90150       {
90151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90152       };
90153     } catch (Dali::DaliException e) {
90154       {
90155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90156       };
90157     } catch (...) {
90158       {
90159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90160       };
90161     }
90162   }
90163
90164 }
90165
90166
90167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90168   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90169
90170   arg1 = (std::vector< Dali::Actor > *)jarg1;
90171   {
90172     try {
90173       delete arg1;
90174     } catch (std::out_of_range& e) {
90175       {
90176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90177       };
90178     } catch (std::exception& e) {
90179       {
90180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90181       };
90182     } catch (Dali::DaliException e) {
90183       {
90184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90185       };
90186     } catch (...) {
90187       {
90188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90189       };
90190     }
90191   }
90192
90193 }
90194
90195
90196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90197   unsigned int jresult ;
90198   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90199   bool result;
90200
90201   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90202   {
90203     try {
90204       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90205     } catch (std::out_of_range& e) {
90206       {
90207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90208       };
90209     } catch (std::exception& e) {
90210       {
90211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (Dali::DaliException e) {
90214       {
90215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90216       };
90217     } catch (...) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90220       };
90221     }
90222   }
90223
90224   jresult = result;
90225   return jresult;
90226 }
90227
90228
90229 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90230   unsigned long jresult ;
90231   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90232   std::size_t result;
90233
90234   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90235   {
90236     try {
90237       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90238     } catch (std::out_of_range& e) {
90239       {
90240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90241       };
90242     } catch (std::exception& e) {
90243       {
90244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90245       };
90246     } catch (Dali::DaliException e) {
90247       {
90248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90249       };
90250     } catch (...) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90253       };
90254     }
90255   }
90256
90257   jresult = (unsigned long)result;
90258   return jresult;
90259 }
90260
90261
90262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90263   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90264   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90265
90266   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90267   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90268   {
90269     try {
90270       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90271     } catch (std::out_of_range& e) {
90272       {
90273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90274       };
90275     } catch (std::exception& e) {
90276       {
90277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90278       };
90279     } catch (Dali::DaliException e) {
90280       {
90281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90282       };
90283     } catch (...) {
90284       {
90285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90286       };
90287     }
90288   }
90289
90290 }
90291
90292
90293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90294   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90295   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90296
90297   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90298   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90299   {
90300     try {
90301       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90302     } catch (std::out_of_range& e) {
90303       {
90304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90305       };
90306     } catch (std::exception& e) {
90307       {
90308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90309       };
90310     } catch (Dali::DaliException e) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90313       };
90314     } catch (...) {
90315       {
90316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90317       };
90318     }
90319   }
90320
90321 }
90322
90323
90324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90325   unsigned int jresult ;
90326   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90327   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90328   bool result;
90329
90330   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90331   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90332   if (!arg2) {
90333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90334     return 0;
90335   }
90336   {
90337     try {
90338       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90339     } catch (std::out_of_range& e) {
90340       {
90341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90342       };
90343     } catch (std::exception& e) {
90344       {
90345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90346       };
90347     } catch (Dali::DaliException e) {
90348       {
90349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90350       };
90351     } catch (...) {
90352       {
90353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90354       };
90355     }
90356   }
90357
90358   jresult = result;
90359   return jresult;
90360 }
90361
90362
90363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90364   void * jresult ;
90365   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90366
90367   {
90368     try {
90369       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (Dali::DaliException e) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90381       };
90382     } catch (...) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90385       };
90386     }
90387   }
90388
90389   jresult = (void *)result;
90390   return jresult;
90391 }
90392
90393
90394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90395   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90396
90397   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90398   {
90399     try {
90400       delete arg1;
90401     } catch (std::out_of_range& e) {
90402       {
90403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90404       };
90405     } catch (std::exception& e) {
90406       {
90407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90408       };
90409     } catch (Dali::DaliException e) {
90410       {
90411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90412       };
90413     } catch (...) {
90414       {
90415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90416       };
90417     }
90418   }
90419
90420 }
90421
90422
90423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90424   unsigned int jresult ;
90425   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90426   bool result;
90427
90428   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90429   {
90430     try {
90431       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);
90432     } catch (std::out_of_range& e) {
90433       {
90434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (std::exception& e) {
90437       {
90438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90439       };
90440     } catch (Dali::DaliException e) {
90441       {
90442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90443       };
90444     } catch (...) {
90445       {
90446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90447       };
90448     }
90449   }
90450
90451   jresult = result;
90452   return jresult;
90453 }
90454
90455
90456 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90457   unsigned long jresult ;
90458   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90459   std::size_t result;
90460
90461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90462   {
90463     try {
90464       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);
90465     } catch (std::out_of_range& e) {
90466       {
90467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90468       };
90469     } catch (std::exception& e) {
90470       {
90471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90472       };
90473     } catch (Dali::DaliException e) {
90474       {
90475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90476       };
90477     } catch (...) {
90478       {
90479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90480       };
90481     }
90482   }
90483
90484   jresult = (unsigned long)result;
90485   return jresult;
90486 }
90487
90488
90489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90490   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90491   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90492
90493   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90494   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90495   {
90496     try {
90497       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90498     } catch (std::out_of_range& e) {
90499       {
90500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90501       };
90502     } catch (std::exception& e) {
90503       {
90504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90505       };
90506     } catch (Dali::DaliException e) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90509       };
90510     } catch (...) {
90511       {
90512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90513       };
90514     }
90515   }
90516
90517 }
90518
90519
90520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90521   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90522   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90523
90524   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90525   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90526   {
90527     try {
90528       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90529     } catch (std::out_of_range& e) {
90530       {
90531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90532       };
90533     } catch (std::exception& e) {
90534       {
90535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90536       };
90537     } catch (Dali::DaliException e) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90540       };
90541     } catch (...) {
90542       {
90543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90544       };
90545     }
90546   }
90547
90548 }
90549
90550
90551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90552   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90553   Dali::Actor arg2 ;
90554   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90555   Dali::Actor *argp2 ;
90556
90557   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90558   argp2 = (Dali::Actor *)jarg2;
90559   if (!argp2) {
90560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90561     return ;
90562   }
90563   arg2 = *argp2;
90564   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90565   {
90566     try {
90567       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90568     } catch (std::out_of_range& e) {
90569       {
90570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90571       };
90572     } catch (std::exception& e) {
90573       {
90574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90575       };
90576     } catch (Dali::DaliException e) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90579       };
90580     } catch (...) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90583       };
90584     }
90585   }
90586
90587 }
90588
90589
90590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90591   void * jresult ;
90592   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90593
90594   {
90595     try {
90596       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90597     } catch (std::out_of_range& e) {
90598       {
90599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90600       };
90601     } catch (std::exception& e) {
90602       {
90603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90604       };
90605     } catch (Dali::DaliException e) {
90606       {
90607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90608       };
90609     } catch (...) {
90610       {
90611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90612       };
90613     }
90614   }
90615
90616   jresult = (void *)result;
90617   return jresult;
90618 }
90619
90620
90621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90622   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90623
90624   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90625   {
90626     try {
90627       delete arg1;
90628     } catch (std::out_of_range& e) {
90629       {
90630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90631       };
90632     } catch (std::exception& e) {
90633       {
90634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90635       };
90636     } catch (Dali::DaliException e) {
90637       {
90638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90639       };
90640     } catch (...) {
90641       {
90642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90643       };
90644     }
90645   }
90646
90647 }
90648
90649
90650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90651   unsigned int jresult ;
90652   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90653   bool result;
90654
90655   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90656   {
90657     try {
90658       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90659     } catch (std::out_of_range& e) {
90660       {
90661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90662       };
90663     } catch (std::exception& e) {
90664       {
90665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90666       };
90667     } catch (Dali::DaliException e) {
90668       {
90669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90670       };
90671     } catch (...) {
90672       {
90673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90674       };
90675     }
90676   }
90677
90678   jresult = result;
90679   return jresult;
90680 }
90681
90682
90683 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90684   unsigned long jresult ;
90685   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90686   std::size_t result;
90687
90688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90689   {
90690     try {
90691       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90692     } catch (std::out_of_range& e) {
90693       {
90694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90695       };
90696     } catch (std::exception& e) {
90697       {
90698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90699       };
90700     } catch (Dali::DaliException e) {
90701       {
90702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90703       };
90704     } catch (...) {
90705       {
90706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90707       };
90708     }
90709   }
90710
90711   jresult = (unsigned long)result;
90712   return jresult;
90713 }
90714
90715
90716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90717   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90718   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90719
90720   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90721   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90722   {
90723     try {
90724       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90725     } catch (std::out_of_range& e) {
90726       {
90727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90728       };
90729     } catch (std::exception& e) {
90730       {
90731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90732       };
90733     } catch (Dali::DaliException e) {
90734       {
90735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90736       };
90737     } catch (...) {
90738       {
90739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90740       };
90741     }
90742   }
90743
90744 }
90745
90746
90747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90748   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90749   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90750
90751   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90752   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90753   {
90754     try {
90755       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90756     } catch (std::out_of_range& e) {
90757       {
90758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90759       };
90760     } catch (std::exception& e) {
90761       {
90762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90763       };
90764     } catch (Dali::DaliException e) {
90765       {
90766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90767       };
90768     } catch (...) {
90769       {
90770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90771       };
90772     }
90773   }
90774
90775 }
90776
90777
90778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90779   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90780   Dali::Actor arg2 ;
90781   Dali::Actor arg3 ;
90782   Dali::Actor *argp2 ;
90783   Dali::Actor *argp3 ;
90784
90785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90786   argp2 = (Dali::Actor *)jarg2;
90787   if (!argp2) {
90788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90789     return ;
90790   }
90791   arg2 = *argp2;
90792   argp3 = (Dali::Actor *)jarg3;
90793   if (!argp3) {
90794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90795     return ;
90796   }
90797   arg3 = *argp3;
90798   {
90799     try {
90800       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90801     } catch (std::out_of_range& e) {
90802       {
90803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90804       };
90805     } catch (std::exception& e) {
90806       {
90807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90808       };
90809     } catch (Dali::DaliException e) {
90810       {
90811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90812       };
90813     } catch (...) {
90814       {
90815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90816       };
90817     }
90818   }
90819
90820 }
90821
90822
90823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90824   void * jresult ;
90825   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90826
90827   {
90828     try {
90829       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90830     } catch (std::out_of_range& e) {
90831       {
90832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (std::exception& e) {
90835       {
90836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90837       };
90838     } catch (Dali::DaliException e) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90841       };
90842     } catch (...) {
90843       {
90844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90845       };
90846     }
90847   }
90848
90849   jresult = (void *)result;
90850   return jresult;
90851 }
90852
90853
90854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90855   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90856
90857   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90858   {
90859     try {
90860       delete arg1;
90861     } catch (std::out_of_range& e) {
90862       {
90863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90864       };
90865     } catch (std::exception& e) {
90866       {
90867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90868       };
90869     } catch (Dali::DaliException e) {
90870       {
90871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90872       };
90873     } catch (...) {
90874       {
90875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90876       };
90877     }
90878   }
90879
90880 }
90881
90882
90883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90884   unsigned int jresult ;
90885   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90886   bool result;
90887
90888   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90889   {
90890     try {
90891       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90892     } catch (std::out_of_range& e) {
90893       {
90894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90895       };
90896     } catch (std::exception& e) {
90897       {
90898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90899       };
90900     } catch (Dali::DaliException e) {
90901       {
90902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90903       };
90904     } catch (...) {
90905       {
90906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90907       };
90908     }
90909   }
90910
90911   jresult = result;
90912   return jresult;
90913 }
90914
90915
90916 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90917   unsigned long jresult ;
90918   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90919   std::size_t result;
90920
90921   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90922   {
90923     try {
90924       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90925     } catch (std::out_of_range& e) {
90926       {
90927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90928       };
90929     } catch (std::exception& e) {
90930       {
90931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90932       };
90933     } catch (Dali::DaliException e) {
90934       {
90935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90936       };
90937     } catch (...) {
90938       {
90939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90940       };
90941     }
90942   }
90943
90944   jresult = (unsigned long)result;
90945   return jresult;
90946 }
90947
90948
90949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90950   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90951   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90952
90953   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90954   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90955   {
90956     try {
90957       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90958     } catch (std::out_of_range& e) {
90959       {
90960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (std::exception& e) {
90963       {
90964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90965       };
90966     } catch (Dali::DaliException e) {
90967       {
90968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90969       };
90970     } catch (...) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90973       };
90974     }
90975   }
90976
90977 }
90978
90979
90980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90981   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90982   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90983
90984   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90985   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90986   {
90987     try {
90988       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90989     } catch (std::out_of_range& e) {
90990       {
90991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90992       };
90993     } catch (std::exception& e) {
90994       {
90995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90996       };
90997     } catch (Dali::DaliException e) {
90998       {
90999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91000       };
91001     } catch (...) {
91002       {
91003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91004       };
91005     }
91006   }
91007
91008 }
91009
91010
91011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
91012   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91013   Dali::Actor arg2 ;
91014   bool arg3 ;
91015   Dali::Actor *argp2 ;
91016
91017   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91018   argp2 = (Dali::Actor *)jarg2;
91019   if (!argp2) {
91020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91021     return ;
91022   }
91023   arg2 = *argp2;
91024   arg3 = jarg3 ? true : false;
91025   {
91026     try {
91027       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
91028     } catch (std::out_of_range& e) {
91029       {
91030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91031       };
91032     } catch (std::exception& e) {
91033       {
91034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91035       };
91036     } catch (Dali::DaliException e) {
91037       {
91038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91039       };
91040     } catch (...) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91043       };
91044     }
91045   }
91046
91047 }
91048
91049
91050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
91051   void * jresult ;
91052   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
91053
91054   {
91055     try {
91056       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
91057     } catch (std::out_of_range& e) {
91058       {
91059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91060       };
91061     } catch (std::exception& e) {
91062       {
91063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91064       };
91065     } catch (Dali::DaliException e) {
91066       {
91067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91068       };
91069     } catch (...) {
91070       {
91071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91072       };
91073     }
91074   }
91075
91076   jresult = (void *)result;
91077   return jresult;
91078 }
91079
91080
91081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91082   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91083
91084   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91085   {
91086     try {
91087       delete arg1;
91088     } catch (std::out_of_range& e) {
91089       {
91090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91091       };
91092     } catch (std::exception& e) {
91093       {
91094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91095       };
91096     } catch (Dali::DaliException e) {
91097       {
91098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91099       };
91100     } catch (...) {
91101       {
91102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91103       };
91104     }
91105   }
91106
91107 }
91108
91109
91110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91111   unsigned int jresult ;
91112   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91113   bool result;
91114
91115   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91116   {
91117     try {
91118       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);
91119     } catch (std::out_of_range& e) {
91120       {
91121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91122       };
91123     } catch (std::exception& e) {
91124       {
91125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91126       };
91127     } catch (Dali::DaliException e) {
91128       {
91129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91130       };
91131     } catch (...) {
91132       {
91133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91134       };
91135     }
91136   }
91137
91138   jresult = result;
91139   return jresult;
91140 }
91141
91142
91143 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91144   unsigned long jresult ;
91145   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91146   std::size_t result;
91147
91148   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91149   {
91150     try {
91151       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);
91152     } catch (std::out_of_range& e) {
91153       {
91154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91155       };
91156     } catch (std::exception& e) {
91157       {
91158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91159       };
91160     } catch (Dali::DaliException e) {
91161       {
91162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91163       };
91164     } catch (...) {
91165       {
91166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91167       };
91168     }
91169   }
91170
91171   jresult = (unsigned long)result;
91172   return jresult;
91173 }
91174
91175
91176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91177   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91178   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91179
91180   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91181   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91182   {
91183     try {
91184       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91185     } catch (std::out_of_range& e) {
91186       {
91187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91188       };
91189     } catch (std::exception& e) {
91190       {
91191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91192       };
91193     } catch (Dali::DaliException e) {
91194       {
91195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91196       };
91197     } catch (...) {
91198       {
91199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91200       };
91201     }
91202   }
91203
91204 }
91205
91206
91207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91208   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91209   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91210
91211   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91212   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91213   {
91214     try {
91215       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91216     } catch (std::out_of_range& e) {
91217       {
91218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91219       };
91220     } catch (std::exception& e) {
91221       {
91222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91223       };
91224     } catch (Dali::DaliException e) {
91225       {
91226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91227       };
91228     } catch (...) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91231       };
91232     }
91233   }
91234
91235 }
91236
91237
91238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91239   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91240   Dali::Toolkit::StyleManager arg2 ;
91241   Dali::StyleChange::Type arg3 ;
91242   Dali::Toolkit::StyleManager *argp2 ;
91243
91244   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91245   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91246   if (!argp2) {
91247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91248     return ;
91249   }
91250   arg2 = *argp2;
91251   arg3 = (Dali::StyleChange::Type)jarg3;
91252   {
91253     try {
91254       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91255     } catch (std::out_of_range& e) {
91256       {
91257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91258       };
91259     } catch (std::exception& e) {
91260       {
91261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91262       };
91263     } catch (Dali::DaliException e) {
91264       {
91265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91266       };
91267     } catch (...) {
91268       {
91269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91270       };
91271     }
91272   }
91273
91274 }
91275
91276
91277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91278   void * jresult ;
91279   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91280
91281   {
91282     try {
91283       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91284     } catch (std::out_of_range& e) {
91285       {
91286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91287       };
91288     } catch (std::exception& e) {
91289       {
91290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91291       };
91292     } catch (Dali::DaliException e) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91295       };
91296     } catch (...) {
91297       {
91298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91299       };
91300     }
91301   }
91302
91303   jresult = (void *)result;
91304   return jresult;
91305 }
91306
91307
91308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91309   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91310
91311   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91312   {
91313     try {
91314       delete arg1;
91315     } catch (std::out_of_range& e) {
91316       {
91317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91318       };
91319     } catch (std::exception& e) {
91320       {
91321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91322       };
91323     } catch (Dali::DaliException e) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91326       };
91327     } catch (...) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91330       };
91331     }
91332   }
91333
91334 }
91335
91336
91337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91338   unsigned int jresult ;
91339   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91340   bool result;
91341
91342   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91343   {
91344     try {
91345       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91346     } catch (std::out_of_range& e) {
91347       {
91348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91349       };
91350     } catch (std::exception& e) {
91351       {
91352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91353       };
91354     } catch (Dali::DaliException e) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91357       };
91358     } catch (...) {
91359       {
91360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91361       };
91362     }
91363   }
91364
91365   jresult = result;
91366   return jresult;
91367 }
91368
91369
91370 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91371   unsigned long jresult ;
91372   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91373   std::size_t result;
91374
91375   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91376   {
91377     try {
91378       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91379     } catch (std::out_of_range& e) {
91380       {
91381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91382       };
91383     } catch (std::exception& e) {
91384       {
91385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91386       };
91387     } catch (Dali::DaliException e) {
91388       {
91389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91390       };
91391     } catch (...) {
91392       {
91393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91394       };
91395     }
91396   }
91397
91398   jresult = (unsigned long)result;
91399   return jresult;
91400 }
91401
91402
91403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91404   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91405   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91406
91407   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91408   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91409   {
91410     try {
91411       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91427       };
91428     }
91429   }
91430
91431 }
91432
91433
91434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91435   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91436   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91437
91438   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91439   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91440   {
91441     try {
91442       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91443     } catch (std::out_of_range& e) {
91444       {
91445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91446       };
91447     } catch (std::exception& e) {
91448       {
91449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91450       };
91451     } catch (Dali::DaliException e) {
91452       {
91453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91454       };
91455     } catch (...) {
91456       {
91457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91458       };
91459     }
91460   }
91461
91462 }
91463
91464
91465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91466   unsigned int jresult ;
91467   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91468   Dali::Toolkit::Button arg2 ;
91469   Dali::Toolkit::Button *argp2 ;
91470   bool result;
91471
91472   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91473   argp2 = (Dali::Toolkit::Button *)jarg2;
91474   if (!argp2) {
91475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91476     return 0;
91477   }
91478   arg2 = *argp2;
91479   {
91480     try {
91481       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91482     } catch (std::out_of_range& e) {
91483       {
91484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91485       };
91486     } catch (std::exception& e) {
91487       {
91488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91489       };
91490     } catch (Dali::DaliException e) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91493       };
91494     } catch (...) {
91495       {
91496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91497       };
91498     }
91499   }
91500
91501   jresult = result;
91502   return jresult;
91503 }
91504
91505
91506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91507   void * jresult ;
91508   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91509
91510   {
91511     try {
91512       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91513     } catch (std::out_of_range& e) {
91514       {
91515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91516       };
91517     } catch (std::exception& e) {
91518       {
91519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91520       };
91521     } catch (Dali::DaliException e) {
91522       {
91523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91524       };
91525     } catch (...) {
91526       {
91527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91528       };
91529     }
91530   }
91531
91532   jresult = (void *)result;
91533   return jresult;
91534 }
91535
91536
91537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91538   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91539
91540   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91541   {
91542     try {
91543       delete arg1;
91544     } catch (std::out_of_range& e) {
91545       {
91546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91547       };
91548     } catch (std::exception& e) {
91549       {
91550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91551       };
91552     } catch (Dali::DaliException e) {
91553       {
91554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91555       };
91556     } catch (...) {
91557       {
91558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91559       };
91560     }
91561   }
91562
91563 }
91564
91565
91566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91567   unsigned int jresult ;
91568   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91569   bool result;
91570
91571   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91572   {
91573     try {
91574       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91575     } catch (std::out_of_range& e) {
91576       {
91577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91578       };
91579     } catch (std::exception& e) {
91580       {
91581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91582       };
91583     } catch (Dali::DaliException e) {
91584       {
91585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91586       };
91587     } catch (...) {
91588       {
91589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91590       };
91591     }
91592   }
91593
91594   jresult = result;
91595   return jresult;
91596 }
91597
91598
91599 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91600   unsigned long jresult ;
91601   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91602   std::size_t result;
91603
91604   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91605   {
91606     try {
91607       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91615       };
91616     } catch (Dali::DaliException e) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91623       };
91624     }
91625   }
91626
91627   jresult = (unsigned long)result;
91628   return jresult;
91629 }
91630
91631
91632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91633   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91634   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91635
91636   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91637   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91638   {
91639     try {
91640       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91641     } catch (std::out_of_range& e) {
91642       {
91643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91644       };
91645     } catch (std::exception& e) {
91646       {
91647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91648       };
91649     } catch (Dali::DaliException e) {
91650       {
91651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91652       };
91653     } catch (...) {
91654       {
91655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91656       };
91657     }
91658   }
91659
91660 }
91661
91662
91663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91664   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91665   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91666
91667   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91668   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91669   {
91670     try {
91671       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91672     } catch (std::out_of_range& e) {
91673       {
91674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91675       };
91676     } catch (std::exception& e) {
91677       {
91678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91679       };
91680     } catch (Dali::DaliException e) {
91681       {
91682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91683       };
91684     } catch (...) {
91685       {
91686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91687       };
91688     }
91689   }
91690
91691 }
91692
91693
91694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91695   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91696   Dali::Toolkit::GaussianBlurView arg2 ;
91697   Dali::Toolkit::GaussianBlurView *argp2 ;
91698
91699   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91700   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91701   if (!argp2) {
91702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91703     return ;
91704   }
91705   arg2 = *argp2;
91706   {
91707     try {
91708       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91709     } catch (std::out_of_range& e) {
91710       {
91711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91712       };
91713     } catch (std::exception& e) {
91714       {
91715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91716       };
91717     } catch (Dali::DaliException e) {
91718       {
91719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91720       };
91721     } catch (...) {
91722       {
91723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91724       };
91725     }
91726   }
91727
91728 }
91729
91730
91731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91732   void * jresult ;
91733   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91734
91735   {
91736     try {
91737       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91738     } catch (std::out_of_range& e) {
91739       {
91740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91741       };
91742     } catch (std::exception& e) {
91743       {
91744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91745       };
91746     } catch (Dali::DaliException e) {
91747       {
91748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91749       };
91750     } catch (...) {
91751       {
91752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91753       };
91754     }
91755   }
91756
91757   jresult = (void *)result;
91758   return jresult;
91759 }
91760
91761
91762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91763   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91764
91765   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91766   {
91767     try {
91768       delete arg1;
91769     } catch (std::out_of_range& e) {
91770       {
91771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91772       };
91773     } catch (std::exception& e) {
91774       {
91775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91776       };
91777     } catch (Dali::DaliException e) {
91778       {
91779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91780       };
91781     } catch (...) {
91782       {
91783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91784       };
91785     }
91786   }
91787
91788 }
91789
91790
91791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91792   unsigned int jresult ;
91793   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91794   bool result;
91795
91796   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91797   {
91798     try {
91799       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);
91800     } catch (std::out_of_range& e) {
91801       {
91802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91803       };
91804     } catch (std::exception& e) {
91805       {
91806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91807       };
91808     } catch (Dali::DaliException e) {
91809       {
91810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91811       };
91812     } catch (...) {
91813       {
91814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91815       };
91816     }
91817   }
91818
91819   jresult = result;
91820   return jresult;
91821 }
91822
91823
91824 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91825   unsigned long jresult ;
91826   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91827   std::size_t result;
91828
91829   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91830   {
91831     try {
91832       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);
91833     } catch (std::out_of_range& e) {
91834       {
91835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91836       };
91837     } catch (std::exception& e) {
91838       {
91839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91840       };
91841     } catch (Dali::DaliException e) {
91842       {
91843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91844       };
91845     } catch (...) {
91846       {
91847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91848       };
91849     }
91850   }
91851
91852   jresult = (unsigned long)result;
91853   return jresult;
91854 }
91855
91856
91857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91858   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91859   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91860
91861   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91862   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91863   {
91864     try {
91865       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91873       };
91874     } catch (Dali::DaliException e) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91877       };
91878     } catch (...) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91881       };
91882     }
91883   }
91884
91885 }
91886
91887
91888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91889   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91890   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91891
91892   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91893   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91894   {
91895     try {
91896       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91897     } catch (std::out_of_range& e) {
91898       {
91899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91900       };
91901     } catch (std::exception& e) {
91902       {
91903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91904       };
91905     } catch (Dali::DaliException e) {
91906       {
91907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91908       };
91909     } catch (...) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91912       };
91913     }
91914   }
91915
91916 }
91917
91918
91919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91920   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91921   Dali::Toolkit::PageTurnView arg2 ;
91922   unsigned int arg3 ;
91923   bool arg4 ;
91924   Dali::Toolkit::PageTurnView *argp2 ;
91925
91926   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91927   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91928   if (!argp2) {
91929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91930     return ;
91931   }
91932   arg2 = *argp2;
91933   arg3 = (unsigned int)jarg3;
91934   arg4 = jarg4 ? true : false;
91935   {
91936     try {
91937       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91938     } catch (std::out_of_range& e) {
91939       {
91940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91941       };
91942     } catch (std::exception& e) {
91943       {
91944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91945       };
91946     } catch (Dali::DaliException e) {
91947       {
91948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91949       };
91950     } catch (...) {
91951       {
91952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91953       };
91954     }
91955   }
91956
91957 }
91958
91959
91960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91961   void * jresult ;
91962   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91963
91964   {
91965     try {
91966       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91967     } catch (std::out_of_range& e) {
91968       {
91969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91970       };
91971     } catch (std::exception& e) {
91972       {
91973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91974       };
91975     } catch (Dali::DaliException e) {
91976       {
91977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91978       };
91979     } catch (...) {
91980       {
91981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91982       };
91983     }
91984   }
91985
91986   jresult = (void *)result;
91987   return jresult;
91988 }
91989
91990
91991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91992   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91993
91994   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91995   {
91996     try {
91997       delete arg1;
91998     } catch (std::out_of_range& e) {
91999       {
92000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92001       };
92002     } catch (std::exception& e) {
92003       {
92004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92005       };
92006     } catch (Dali::DaliException e) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92009       };
92010     } catch (...) {
92011       {
92012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92013       };
92014     }
92015   }
92016
92017 }
92018
92019
92020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
92021   unsigned int jresult ;
92022   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92023   bool result;
92024
92025   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92026   {
92027     try {
92028       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92029     } catch (std::out_of_range& e) {
92030       {
92031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92032       };
92033     } catch (std::exception& e) {
92034       {
92035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92036       };
92037     } catch (Dali::DaliException e) {
92038       {
92039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92040       };
92041     } catch (...) {
92042       {
92043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92044       };
92045     }
92046   }
92047
92048   jresult = result;
92049   return jresult;
92050 }
92051
92052
92053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
92054   unsigned long jresult ;
92055   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92056   std::size_t result;
92057
92058   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92059   {
92060     try {
92061       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92062     } catch (std::out_of_range& e) {
92063       {
92064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92065       };
92066     } catch (std::exception& e) {
92067       {
92068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92069       };
92070     } catch (Dali::DaliException e) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92073       };
92074     } catch (...) {
92075       {
92076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92077       };
92078     }
92079   }
92080
92081   jresult = (unsigned long)result;
92082   return jresult;
92083 }
92084
92085
92086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92087   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92088   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92089
92090   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92091   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92092   {
92093     try {
92094       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92095     } catch (std::out_of_range& e) {
92096       {
92097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92098       };
92099     } catch (std::exception& e) {
92100       {
92101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92102       };
92103     } catch (Dali::DaliException e) {
92104       {
92105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92106       };
92107     } catch (...) {
92108       {
92109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92110       };
92111     }
92112   }
92113
92114 }
92115
92116
92117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92118   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92119   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92120
92121   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92122   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92123   {
92124     try {
92125       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92126     } catch (std::out_of_range& e) {
92127       {
92128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92129       };
92130     } catch (std::exception& e) {
92131       {
92132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92133       };
92134     } catch (Dali::DaliException e) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92137       };
92138     } catch (...) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92141       };
92142     }
92143   }
92144
92145 }
92146
92147
92148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92149   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92150   Dali::Toolkit::PageTurnView arg2 ;
92151   Dali::Toolkit::PageTurnView *argp2 ;
92152
92153   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92154   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92155   if (!argp2) {
92156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92157     return ;
92158   }
92159   arg2 = *argp2;
92160   {
92161     try {
92162       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92163     } catch (std::out_of_range& e) {
92164       {
92165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92166       };
92167     } catch (std::exception& e) {
92168       {
92169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92170       };
92171     } catch (Dali::DaliException e) {
92172       {
92173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92174       };
92175     } catch (...) {
92176       {
92177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92178       };
92179     }
92180   }
92181
92182 }
92183
92184
92185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92186   void * jresult ;
92187   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92188
92189   {
92190     try {
92191       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92192     } catch (std::out_of_range& e) {
92193       {
92194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92195       };
92196     } catch (std::exception& e) {
92197       {
92198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92199       };
92200     } catch (Dali::DaliException e) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92203       };
92204     } catch (...) {
92205       {
92206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92207       };
92208     }
92209   }
92210
92211   jresult = (void *)result;
92212   return jresult;
92213 }
92214
92215
92216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92217   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92218
92219   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92220   {
92221     try {
92222       delete arg1;
92223     } catch (std::out_of_range& e) {
92224       {
92225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92226       };
92227     } catch (std::exception& e) {
92228       {
92229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92230       };
92231     } catch (Dali::DaliException e) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92234       };
92235     } catch (...) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92238       };
92239     }
92240   }
92241
92242 }
92243
92244
92245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92246   unsigned int jresult ;
92247   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92248   bool result;
92249
92250   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92251   {
92252     try {
92253       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);
92254     } catch (std::out_of_range& e) {
92255       {
92256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (std::exception& e) {
92259       {
92260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92261       };
92262     } catch (Dali::DaliException e) {
92263       {
92264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92265       };
92266     } catch (...) {
92267       {
92268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92269       };
92270     }
92271   }
92272
92273   jresult = result;
92274   return jresult;
92275 }
92276
92277
92278 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92279   unsigned long jresult ;
92280   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92281   std::size_t result;
92282
92283   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92284   {
92285     try {
92286       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);
92287     } catch (std::out_of_range& e) {
92288       {
92289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92290       };
92291     } catch (std::exception& e) {
92292       {
92293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92294       };
92295     } catch (Dali::DaliException e) {
92296       {
92297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92298       };
92299     } catch (...) {
92300       {
92301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92302       };
92303     }
92304   }
92305
92306   jresult = (unsigned long)result;
92307   return jresult;
92308 }
92309
92310
92311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92312   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92313   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92314
92315   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92316   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92317   {
92318     try {
92319       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92320     } catch (std::out_of_range& e) {
92321       {
92322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92323       };
92324     } catch (std::exception& e) {
92325       {
92326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92327       };
92328     } catch (Dali::DaliException e) {
92329       {
92330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92331       };
92332     } catch (...) {
92333       {
92334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92335       };
92336     }
92337   }
92338
92339 }
92340
92341
92342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92343   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92344   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92345
92346   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92347   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92348   {
92349     try {
92350       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92351     } catch (std::out_of_range& e) {
92352       {
92353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92354       };
92355     } catch (std::exception& e) {
92356       {
92357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92358       };
92359     } catch (Dali::DaliException e) {
92360       {
92361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92362       };
92363     } catch (...) {
92364       {
92365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92366       };
92367     }
92368   }
92369
92370 }
92371
92372
92373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92374   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92375   Dali::Toolkit::ProgressBar arg2 ;
92376   float arg3 ;
92377   float arg4 ;
92378   Dali::Toolkit::ProgressBar *argp2 ;
92379
92380   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92381   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92382   if (!argp2) {
92383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92384     return ;
92385   }
92386   arg2 = *argp2;
92387   arg3 = (float)jarg3;
92388   arg4 = (float)jarg4;
92389   {
92390     try {
92391       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92392     } catch (std::out_of_range& e) {
92393       {
92394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92395       };
92396     } catch (std::exception& e) {
92397       {
92398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92399       };
92400     } catch (Dali::DaliException e) {
92401       {
92402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92403       };
92404     } catch (...) {
92405       {
92406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92407       };
92408     }
92409   }
92410
92411 }
92412
92413
92414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92415   void * jresult ;
92416   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92417
92418   {
92419     try {
92420       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92421     } catch (std::out_of_range& e) {
92422       {
92423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92424       };
92425     } catch (std::exception& e) {
92426       {
92427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92428       };
92429     } catch (Dali::DaliException e) {
92430       {
92431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92432       };
92433     } catch (...) {
92434       {
92435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92436       };
92437     }
92438   }
92439
92440   jresult = (void *)result;
92441   return jresult;
92442 }
92443
92444
92445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92446   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92447
92448   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92449   {
92450     try {
92451       delete arg1;
92452     } catch (std::out_of_range& e) {
92453       {
92454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92455       };
92456     } catch (std::exception& e) {
92457       {
92458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92459       };
92460     } catch (Dali::DaliException e) {
92461       {
92462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92463       };
92464     } catch (...) {
92465       {
92466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92467       };
92468     }
92469   }
92470
92471 }
92472
92473
92474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92475   unsigned int jresult ;
92476   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92477   bool result;
92478
92479   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92480   {
92481     try {
92482       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);
92483     } catch (std::out_of_range& e) {
92484       {
92485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92486       };
92487     } catch (std::exception& e) {
92488       {
92489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92490       };
92491     } catch (Dali::DaliException e) {
92492       {
92493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92494       };
92495     } catch (...) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92498       };
92499     }
92500   }
92501
92502   jresult = result;
92503   return jresult;
92504 }
92505
92506
92507 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92508   unsigned long jresult ;
92509   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92510   std::size_t result;
92511
92512   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92513   {
92514     try {
92515       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);
92516     } catch (std::out_of_range& e) {
92517       {
92518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92519       };
92520     } catch (std::exception& e) {
92521       {
92522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92523       };
92524     } catch (Dali::DaliException e) {
92525       {
92526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92527       };
92528     } catch (...) {
92529       {
92530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92531       };
92532     }
92533   }
92534
92535   jresult = (unsigned long)result;
92536   return jresult;
92537 }
92538
92539
92540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92541   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92542   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92543
92544   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92545   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92546   {
92547     try {
92548       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92564       };
92565     }
92566   }
92567
92568 }
92569
92570
92571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92572   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92573   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92574
92575   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92576   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92577   {
92578     try {
92579       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92587       };
92588     } catch (Dali::DaliException e) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92591       };
92592     } catch (...) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92595       };
92596     }
92597   }
92598
92599 }
92600
92601
92602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92603   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92604   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92605
92606   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92607   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92608   if (!arg2) {
92609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92610     return ;
92611   }
92612   {
92613     try {
92614       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92615     } catch (std::out_of_range& e) {
92616       {
92617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92618       };
92619     } catch (std::exception& e) {
92620       {
92621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92622       };
92623     } catch (Dali::DaliException e) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92626       };
92627     } catch (...) {
92628       {
92629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92630       };
92631     }
92632   }
92633
92634 }
92635
92636
92637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92638   void * jresult ;
92639   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92640
92641   {
92642     try {
92643       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92644     } catch (std::out_of_range& e) {
92645       {
92646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92647       };
92648     } catch (std::exception& e) {
92649       {
92650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92651       };
92652     } catch (Dali::DaliException e) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92655       };
92656     } catch (...) {
92657       {
92658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92659       };
92660     }
92661   }
92662
92663   jresult = (void *)result;
92664   return jresult;
92665 }
92666
92667
92668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92669   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92670
92671   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92672   {
92673     try {
92674       delete arg1;
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92690       };
92691     }
92692   }
92693
92694 }
92695
92696
92697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92698   unsigned int jresult ;
92699   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92700   bool result;
92701
92702   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92703   {
92704     try {
92705       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92706     } catch (std::out_of_range& e) {
92707       {
92708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92709       };
92710     } catch (std::exception& e) {
92711       {
92712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (Dali::DaliException e) {
92715       {
92716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92717       };
92718     } catch (...) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92721       };
92722     }
92723   }
92724
92725   jresult = result;
92726   return jresult;
92727 }
92728
92729
92730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92731   unsigned long jresult ;
92732   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92733   std::size_t result;
92734
92735   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92736   {
92737     try {
92738       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92739     } catch (std::out_of_range& e) {
92740       {
92741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92742       };
92743     } catch (std::exception& e) {
92744       {
92745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92746       };
92747     } catch (Dali::DaliException e) {
92748       {
92749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92750       };
92751     } catch (...) {
92752       {
92753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92754       };
92755     }
92756   }
92757
92758   jresult = (unsigned long)result;
92759   return jresult;
92760 }
92761
92762
92763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92764   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92765   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92766
92767   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92768   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92769   {
92770     try {
92771       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92772     } catch (std::out_of_range& e) {
92773       {
92774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92775       };
92776     } catch (std::exception& e) {
92777       {
92778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92779       };
92780     } catch (Dali::DaliException e) {
92781       {
92782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92783       };
92784     } catch (...) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92787       };
92788     }
92789   }
92790
92791 }
92792
92793
92794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92795   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92796   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92797
92798   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92799   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92800   {
92801     try {
92802       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92803     } catch (std::out_of_range& e) {
92804       {
92805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92806       };
92807     } catch (std::exception& e) {
92808       {
92809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92810       };
92811     } catch (Dali::DaliException e) {
92812       {
92813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92814       };
92815     } catch (...) {
92816       {
92817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92818       };
92819     }
92820   }
92821
92822 }
92823
92824
92825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92826   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92827   Dali::Vector2 *arg2 = 0 ;
92828
92829   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92830   arg2 = (Dali::Vector2 *)jarg2;
92831   if (!arg2) {
92832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92833     return ;
92834   }
92835   {
92836     try {
92837       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92838     } catch (std::out_of_range& e) {
92839       {
92840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92841       };
92842     } catch (std::exception& e) {
92843       {
92844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92845       };
92846     } catch (Dali::DaliException e) {
92847       {
92848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92849       };
92850     } catch (...) {
92851       {
92852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92853       };
92854     }
92855   }
92856
92857 }
92858
92859
92860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92861   void * jresult ;
92862   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92863
92864   {
92865     try {
92866       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92867     } catch (std::out_of_range& e) {
92868       {
92869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92870       };
92871     } catch (std::exception& e) {
92872       {
92873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92874       };
92875     } catch (Dali::DaliException e) {
92876       {
92877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92878       };
92879     } catch (...) {
92880       {
92881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92882       };
92883     }
92884   }
92885
92886   jresult = (void *)result;
92887   return jresult;
92888 }
92889
92890
92891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92892   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92893
92894   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92895   {
92896     try {
92897       delete arg1;
92898     } catch (std::out_of_range& e) {
92899       {
92900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92901       };
92902     } catch (std::exception& e) {
92903       {
92904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92905       };
92906     } catch (Dali::DaliException e) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92909       };
92910     } catch (...) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92913       };
92914     }
92915   }
92916
92917 }
92918
92919
92920
92921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92922   unsigned int jresult ;
92923   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92924   bool result;
92925
92926   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92927   {
92928     try {
92929       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);
92930     } catch (std::out_of_range& e) {
92931       {
92932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92933       };
92934     } catch (std::exception& e) {
92935       {
92936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92937       };
92938     } catch (Dali::DaliException e) {
92939       {
92940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92941       };
92942     } catch (...) {
92943       {
92944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92945       };
92946     }
92947   }
92948
92949   jresult = result;
92950   return jresult;
92951 }
92952
92953
92954 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92955   unsigned long jresult ;
92956   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92957   std::size_t result;
92958
92959   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92960   {
92961     try {
92962       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);
92963     } catch (std::out_of_range& e) {
92964       {
92965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92966       };
92967     } catch (std::exception& e) {
92968       {
92969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92970       };
92971     } catch (Dali::DaliException e) {
92972       {
92973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92974       };
92975     } catch (...) {
92976       {
92977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92978       };
92979     }
92980   }
92981
92982   jresult = (unsigned long)result;
92983   return jresult;
92984 }
92985
92986
92987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92988   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92989   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92990
92991   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92992   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92993   {
92994     try {
92995       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92996     } catch (std::out_of_range& e) {
92997       {
92998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92999       };
93000     } catch (std::exception& e) {
93001       {
93002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93003       };
93004     } catch (Dali::DaliException e) {
93005       {
93006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93007       };
93008     } catch (...) {
93009       {
93010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93011       };
93012     }
93013   }
93014
93015 }
93016
93017
93018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
93019   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93020   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93021
93022   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93023   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93024   {
93025     try {
93026       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93027     } catch (std::out_of_range& e) {
93028       {
93029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93030       };
93031     } catch (std::exception& e) {
93032       {
93033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93034       };
93035     } catch (Dali::DaliException e) {
93036       {
93037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93038       };
93039     } catch (...) {
93040       {
93041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93042       };
93043     }
93044   }
93045
93046 }
93047
93048
93049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93050   unsigned int jresult ;
93051   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93052   Dali::Toolkit::Control arg2 ;
93053   Dali::KeyEvent *arg3 = 0 ;
93054   Dali::Toolkit::Control *argp2 ;
93055   bool result;
93056
93057   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93058   argp2 = (Dali::Toolkit::Control *)jarg2;
93059   if (!argp2) {
93060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93061     return 0;
93062   }
93063   arg2 = *argp2;
93064   arg3 = (Dali::KeyEvent *)jarg3;
93065   if (!arg3) {
93066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93067     return 0;
93068   }
93069   {
93070     try {
93071       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);
93072     } catch (std::out_of_range& e) {
93073       {
93074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93075       };
93076     } catch (std::exception& e) {
93077       {
93078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93079       };
93080     } catch (Dali::DaliException e) {
93081       {
93082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93083       };
93084     } catch (...) {
93085       {
93086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93087       };
93088     }
93089   }
93090
93091   jresult = result;
93092   return jresult;
93093 }
93094
93095
93096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93097   void * jresult ;
93098   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93099
93100   {
93101     try {
93102       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93103     } catch (std::out_of_range& e) {
93104       {
93105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93106       };
93107     } catch (std::exception& e) {
93108       {
93109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93110       };
93111     } catch (Dali::DaliException e) {
93112       {
93113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93114       };
93115     } catch (...) {
93116       {
93117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93118       };
93119     }
93120   }
93121
93122   jresult = (void *)result;
93123   return jresult;
93124 }
93125
93126
93127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93128   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93129
93130   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93131   {
93132     try {
93133       delete arg1;
93134     } catch (std::out_of_range& e) {
93135       {
93136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93137       };
93138     } catch (std::exception& e) {
93139       {
93140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93141       };
93142     } catch (Dali::DaliException e) {
93143       {
93144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93145       };
93146     } catch (...) {
93147       {
93148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93149       };
93150     }
93151   }
93152
93153 }
93154
93155
93156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93157   unsigned int jresult ;
93158   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93159   bool result;
93160
93161   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93162   {
93163     try {
93164       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93165     } catch (std::out_of_range& e) {
93166       {
93167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93168       };
93169     } catch (std::exception& e) {
93170       {
93171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93172       };
93173     } catch (Dali::DaliException e) {
93174       {
93175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93176       };
93177     } catch (...) {
93178       {
93179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93180       };
93181     }
93182   }
93183
93184   jresult = result;
93185   return jresult;
93186 }
93187
93188
93189 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93190   unsigned long jresult ;
93191   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93192   std::size_t result;
93193
93194   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93195   {
93196     try {
93197       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93198     } catch (std::out_of_range& e) {
93199       {
93200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93201       };
93202     } catch (std::exception& e) {
93203       {
93204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93205       };
93206     } catch (Dali::DaliException e) {
93207       {
93208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93209       };
93210     } catch (...) {
93211       {
93212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93213       };
93214     }
93215   }
93216
93217   jresult = (unsigned long)result;
93218   return jresult;
93219 }
93220
93221
93222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93223   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93224   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93225
93226   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93227   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93228   {
93229     try {
93230       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93231     } catch (std::out_of_range& e) {
93232       {
93233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93234       };
93235     } catch (std::exception& e) {
93236       {
93237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93238       };
93239     } catch (Dali::DaliException e) {
93240       {
93241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93242       };
93243     } catch (...) {
93244       {
93245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93246       };
93247     }
93248   }
93249
93250 }
93251
93252
93253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93254   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93255   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93256
93257   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93258   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93259   {
93260     try {
93261       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93262     } catch (std::out_of_range& e) {
93263       {
93264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93265       };
93266     } catch (std::exception& e) {
93267       {
93268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93269       };
93270     } catch (Dali::DaliException e) {
93271       {
93272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93273       };
93274     } catch (...) {
93275       {
93276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93277       };
93278     }
93279   }
93280
93281 }
93282
93283
93284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93285   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93286   Dali::Toolkit::Control arg2 ;
93287   Dali::Toolkit::Control *argp2 ;
93288
93289   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93290   argp2 = (Dali::Toolkit::Control *)jarg2;
93291   if (!argp2) {
93292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93293     return ;
93294   }
93295   arg2 = *argp2;
93296   {
93297     try {
93298       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93299     } catch (std::out_of_range& e) {
93300       {
93301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93302       };
93303     } catch (std::exception& e) {
93304       {
93305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93306       };
93307     } catch (Dali::DaliException e) {
93308       {
93309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93310       };
93311     } catch (...) {
93312       {
93313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93314       };
93315     }
93316   }
93317
93318 }
93319
93320
93321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93322   void * jresult ;
93323   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93324
93325   {
93326     try {
93327       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93328     } catch (std::out_of_range& e) {
93329       {
93330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93331       };
93332     } catch (std::exception& e) {
93333       {
93334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93335       };
93336     } catch (Dali::DaliException e) {
93337       {
93338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93339       };
93340     } catch (...) {
93341       {
93342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93343       };
93344     }
93345   }
93346
93347   jresult = (void *)result;
93348   return jresult;
93349 }
93350
93351
93352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93353   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93354
93355   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93356   {
93357     try {
93358       delete arg1;
93359     } catch (std::out_of_range& e) {
93360       {
93361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93362       };
93363     } catch (std::exception& e) {
93364       {
93365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93366       };
93367     } catch (Dali::DaliException e) {
93368       {
93369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93370       };
93371     } catch (...) {
93372       {
93373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93374       };
93375     }
93376   }
93377
93378 }
93379
93380
93381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93382   unsigned int jresult ;
93383   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93384   bool result;
93385
93386   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93387   {
93388     try {
93389       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93390     } catch (std::out_of_range& e) {
93391       {
93392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93393       };
93394     } catch (std::exception& e) {
93395       {
93396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93397       };
93398     } catch (Dali::DaliException e) {
93399       {
93400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93401       };
93402     } catch (...) {
93403       {
93404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93405       };
93406     }
93407   }
93408
93409   jresult = result;
93410   return jresult;
93411 }
93412
93413
93414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93415   unsigned long jresult ;
93416   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93417   std::size_t result;
93418
93419   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93420   {
93421     try {
93422       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93423     } catch (std::out_of_range& e) {
93424       {
93425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93426       };
93427     } catch (std::exception& e) {
93428       {
93429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93430       };
93431     } catch (Dali::DaliException e) {
93432       {
93433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93434       };
93435     } catch (...) {
93436       {
93437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93438       };
93439     }
93440   }
93441
93442   jresult = (unsigned long)result;
93443   return jresult;
93444 }
93445
93446
93447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93448   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93449   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93450
93451   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93452   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93453   {
93454     try {
93455       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93456     } catch (std::out_of_range& e) {
93457       {
93458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93459       };
93460     } catch (std::exception& e) {
93461       {
93462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93463       };
93464     } catch (Dali::DaliException e) {
93465       {
93466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93467       };
93468     } catch (...) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93471       };
93472     }
93473   }
93474
93475 }
93476
93477
93478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93479   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93480   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93481
93482   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93483   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93484   {
93485     try {
93486       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93487     } catch (std::out_of_range& e) {
93488       {
93489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93490       };
93491     } catch (std::exception& e) {
93492       {
93493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93494       };
93495     } catch (Dali::DaliException e) {
93496       {
93497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93498       };
93499     } catch (...) {
93500       {
93501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93502       };
93503     }
93504   }
93505
93506 }
93507
93508
93509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93510   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93511   Dali::Toolkit::VideoView *arg2 = 0 ;
93512
93513   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93514   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93515   if (!arg2) {
93516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93517     return ;
93518   }
93519   {
93520     try {
93521       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93522     } catch (std::out_of_range& e) {
93523       {
93524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93525       };
93526     } catch (std::exception& e) {
93527       {
93528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93529       };
93530     } catch (Dali::DaliException e) {
93531       {
93532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93533       };
93534     } catch (...) {
93535       {
93536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93537       };
93538     }
93539   }
93540
93541 }
93542
93543
93544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93545   void * jresult ;
93546   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93547
93548   {
93549     try {
93550       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93551     } catch (std::out_of_range& e) {
93552       {
93553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93554       };
93555     } catch (std::exception& e) {
93556       {
93557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93558       };
93559     } catch (Dali::DaliException e) {
93560       {
93561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93562       };
93563     } catch (...) {
93564       {
93565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93566       };
93567     }
93568   }
93569
93570   jresult = (void *)result;
93571   return jresult;
93572 }
93573
93574
93575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93576   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93577
93578   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93579   {
93580     try {
93581       delete arg1;
93582     } catch (std::out_of_range& e) {
93583       {
93584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93585       };
93586     } catch (std::exception& e) {
93587       {
93588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93589       };
93590     } catch (Dali::DaliException e) {
93591       {
93592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93593       };
93594     } catch (...) {
93595       {
93596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93597       };
93598     }
93599   }
93600
93601 }
93602
93603
93604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93605   unsigned int jresult ;
93606   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93607   bool result;
93608
93609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93610   {
93611     try {
93612       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93613     } catch (std::out_of_range& e) {
93614       {
93615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93616       };
93617     } catch (std::exception& e) {
93618       {
93619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93620       };
93621     } catch (Dali::DaliException e) {
93622       {
93623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93624       };
93625     } catch (...) {
93626       {
93627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93628       };
93629     }
93630   }
93631
93632   jresult = result;
93633   return jresult;
93634 }
93635
93636
93637 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93638   unsigned long jresult ;
93639   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93640   std::size_t result;
93641
93642   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93643   {
93644     try {
93645       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93646     } catch (std::out_of_range& e) {
93647       {
93648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93649       };
93650     } catch (std::exception& e) {
93651       {
93652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93653       };
93654     } catch (Dali::DaliException e) {
93655       {
93656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93657       };
93658     } catch (...) {
93659       {
93660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93661       };
93662     }
93663   }
93664
93665   jresult = (unsigned long)result;
93666   return jresult;
93667 }
93668
93669
93670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93671   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93672   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93673
93674   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93675   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93676   {
93677     try {
93678       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93679     } catch (std::out_of_range& e) {
93680       {
93681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93682       };
93683     } catch (std::exception& e) {
93684       {
93685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93686       };
93687     } catch (Dali::DaliException e) {
93688       {
93689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93690       };
93691     } catch (...) {
93692       {
93693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93694       };
93695     }
93696   }
93697
93698 }
93699
93700
93701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93702   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93703   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93704
93705   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93706   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93707   {
93708     try {
93709       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93710     } catch (std::out_of_range& e) {
93711       {
93712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93713       };
93714     } catch (std::exception& e) {
93715       {
93716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93717       };
93718     } catch (Dali::DaliException e) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93721       };
93722     } catch (...) {
93723       {
93724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93725       };
93726     }
93727   }
93728
93729 }
93730
93731
93732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93733   unsigned int jresult ;
93734   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93735   Dali::Toolkit::Slider arg2 ;
93736   float arg3 ;
93737   Dali::Toolkit::Slider *argp2 ;
93738   bool result;
93739
93740   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93741   argp2 = (Dali::Toolkit::Slider *)jarg2;
93742   if (!argp2) {
93743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93744     return 0;
93745   }
93746   arg2 = *argp2;
93747   arg3 = (float)jarg3;
93748   {
93749     try {
93750       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93751     } catch (std::out_of_range& e) {
93752       {
93753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93754       };
93755     } catch (std::exception& e) {
93756       {
93757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93758       };
93759     } catch (Dali::DaliException e) {
93760       {
93761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93762       };
93763     } catch (...) {
93764       {
93765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93766       };
93767     }
93768   }
93769
93770   jresult = result;
93771   return jresult;
93772 }
93773
93774
93775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93776   void * jresult ;
93777   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93778
93779   {
93780     try {
93781       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93782     } catch (std::out_of_range& e) {
93783       {
93784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93785       };
93786     } catch (std::exception& e) {
93787       {
93788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93789       };
93790     } catch (Dali::DaliException e) {
93791       {
93792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93793       };
93794     } catch (...) {
93795       {
93796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93797       };
93798     }
93799   }
93800
93801   jresult = (void *)result;
93802   return jresult;
93803 }
93804
93805
93806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93807   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93808
93809   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93810   {
93811     try {
93812       delete arg1;
93813     } catch (std::out_of_range& e) {
93814       {
93815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93816       };
93817     } catch (std::exception& e) {
93818       {
93819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93820       };
93821     } catch (Dali::DaliException e) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93824       };
93825     } catch (...) {
93826       {
93827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93828       };
93829     }
93830   }
93831
93832 }
93833
93834
93835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93836   unsigned int jresult ;
93837   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93838   bool result;
93839
93840   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93841   {
93842     try {
93843       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93844     } catch (std::out_of_range& e) {
93845       {
93846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93847       };
93848     } catch (std::exception& e) {
93849       {
93850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93851       };
93852     } catch (Dali::DaliException e) {
93853       {
93854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93855       };
93856     } catch (...) {
93857       {
93858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93859       };
93860     }
93861   }
93862
93863   jresult = result;
93864   return jresult;
93865 }
93866
93867
93868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93869   unsigned long jresult ;
93870   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93871   std::size_t result;
93872
93873   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93874   {
93875     try {
93876       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93877     } catch (std::out_of_range& e) {
93878       {
93879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93880       };
93881     } catch (std::exception& e) {
93882       {
93883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93884       };
93885     } catch (Dali::DaliException e) {
93886       {
93887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93888       };
93889     } catch (...) {
93890       {
93891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93892       };
93893     }
93894   }
93895
93896   jresult = (unsigned long)result;
93897   return jresult;
93898 }
93899
93900
93901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93902   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93903   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93904
93905   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93906   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93907   {
93908     try {
93909       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93910     } catch (std::out_of_range& e) {
93911       {
93912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93913       };
93914     } catch (std::exception& e) {
93915       {
93916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93917       };
93918     } catch (Dali::DaliException e) {
93919       {
93920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93921       };
93922     } catch (...) {
93923       {
93924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93925       };
93926     }
93927   }
93928
93929 }
93930
93931
93932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93933   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93934   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93935
93936   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93937   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93938   {
93939     try {
93940       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93941     } catch (std::out_of_range& e) {
93942       {
93943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93944       };
93945     } catch (std::exception& e) {
93946       {
93947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93948       };
93949     } catch (Dali::DaliException e) {
93950       {
93951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93952       };
93953     } catch (...) {
93954       {
93955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93956       };
93957     }
93958   }
93959
93960 }
93961
93962
93963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93964   unsigned int jresult ;
93965   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93966   Dali::Toolkit::Slider arg2 ;
93967   int arg3 ;
93968   Dali::Toolkit::Slider *argp2 ;
93969   bool result;
93970
93971   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93972   argp2 = (Dali::Toolkit::Slider *)jarg2;
93973   if (!argp2) {
93974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93975     return 0;
93976   }
93977   arg2 = *argp2;
93978   arg3 = (int)jarg3;
93979   {
93980     try {
93981       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93982     } catch (std::out_of_range& e) {
93983       {
93984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93985       };
93986     } catch (std::exception& e) {
93987       {
93988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93989       };
93990     } catch (Dali::DaliException e) {
93991       {
93992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93993       };
93994     } catch (...) {
93995       {
93996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93997       };
93998     }
93999   }
94000
94001   jresult = result;
94002   return jresult;
94003 }
94004
94005
94006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
94007   void * jresult ;
94008   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
94009
94010   {
94011     try {
94012       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
94013     } catch (std::out_of_range& e) {
94014       {
94015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94016       };
94017     } catch (std::exception& e) {
94018       {
94019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94020       };
94021     } catch (Dali::DaliException e) {
94022       {
94023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94024       };
94025     } catch (...) {
94026       {
94027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94028       };
94029     }
94030   }
94031
94032   jresult = (void *)result;
94033   return jresult;
94034 }
94035
94036
94037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
94038   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94039
94040   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94041   {
94042     try {
94043       delete arg1;
94044     } catch (std::out_of_range& e) {
94045       {
94046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94047       };
94048     } catch (std::exception& e) {
94049       {
94050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94051       };
94052     } catch (Dali::DaliException e) {
94053       {
94054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94055       };
94056     } catch (...) {
94057       {
94058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94059       };
94060     }
94061   }
94062
94063 }
94064
94065
94066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94067   void * jresult ;
94068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94069
94070   {
94071     try {
94072       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94073     } catch (std::out_of_range& e) {
94074       {
94075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94076       };
94077     } catch (std::exception& e) {
94078       {
94079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94080       };
94081     } catch (Dali::DaliException e) {
94082       {
94083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94084       };
94085     } catch (...) {
94086       {
94087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94088       };
94089     }
94090   }
94091
94092   jresult = (void *)result;
94093   return jresult;
94094 }
94095
94096
94097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94098   void * jresult ;
94099   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94100   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94101
94102   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94103   {
94104     try {
94105       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94106     } catch (std::out_of_range& e) {
94107       {
94108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94109       };
94110     } catch (std::exception& e) {
94111       {
94112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94113       };
94114     } catch (Dali::DaliException e) {
94115       {
94116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94117       };
94118     } catch (...) {
94119       {
94120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94121       };
94122     }
94123   }
94124
94125   jresult = (void *)result;
94126   return jresult;
94127 }
94128
94129
94130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94131   void * jresult ;
94132   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94134
94135   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94136   if (!arg1) {
94137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94138     return 0;
94139   }
94140   {
94141     try {
94142       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94143     } catch (std::out_of_range& e) {
94144       {
94145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94146       };
94147     } catch (std::exception& e) {
94148       {
94149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94150       };
94151     } catch (Dali::DaliException e) {
94152       {
94153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94154       };
94155     } catch (...) {
94156       {
94157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94158       };
94159     }
94160   }
94161
94162   jresult = (void *)result;
94163   return jresult;
94164 }
94165
94166
94167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94168   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94169
94170   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94171   {
94172     try {
94173       delete arg1;
94174     } catch (std::out_of_range& e) {
94175       {
94176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94177       };
94178     } catch (std::exception& e) {
94179       {
94180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94181       };
94182     } catch (Dali::DaliException e) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94185       };
94186     } catch (...) {
94187       {
94188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94189       };
94190     }
94191   }
94192
94193 }
94194
94195
94196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94197   void * jresult ;
94198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94199   Dali::Toolkit::Ruler *result = 0 ;
94200
94201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94202   {
94203     try {
94204       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94205     } catch (std::out_of_range& e) {
94206       {
94207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94208       };
94209     } catch (std::exception& e) {
94210       {
94211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94212       };
94213     } catch (Dali::DaliException e) {
94214       {
94215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94216       };
94217     } catch (...) {
94218       {
94219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94220       };
94221     }
94222   }
94223
94224   jresult = (void *)result;
94225   return jresult;
94226 }
94227
94228
94229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94230   void * jresult ;
94231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94232   Dali::Toolkit::Ruler *result = 0 ;
94233
94234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94235   {
94236     try {
94237       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94238     } catch (std::out_of_range& e) {
94239       {
94240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94241       };
94242     } catch (std::exception& e) {
94243       {
94244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94245       };
94246     } catch (Dali::DaliException e) {
94247       {
94248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94249       };
94250     } catch (...) {
94251       {
94252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94253       };
94254     }
94255   }
94256
94257   jresult = (void *)result;
94258   return jresult;
94259 }
94260
94261
94262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94263   void * jresult ;
94264   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94265   Dali::Toolkit::Ruler *result = 0 ;
94266
94267   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94268   {
94269     try {
94270       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94271     } catch (std::out_of_range& e) {
94272       {
94273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94274       };
94275     } catch (std::exception& e) {
94276       {
94277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94278       };
94279     } catch (Dali::DaliException e) {
94280       {
94281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94282       };
94283     } catch (...) {
94284       {
94285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94286       };
94287     }
94288   }
94289
94290   jresult = (void *)result;
94291   return jresult;
94292 }
94293
94294
94295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94296   void * jresult ;
94297   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94298   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94299   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94300
94301   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94302   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94303   if (!arg2) {
94304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94305     return 0;
94306   }
94307   {
94308     try {
94309       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94310     } catch (std::out_of_range& e) {
94311       {
94312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94313       };
94314     } catch (std::exception& e) {
94315       {
94316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94317       };
94318     } catch (Dali::DaliException e) {
94319       {
94320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94321       };
94322     } catch (...) {
94323       {
94324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94325       };
94326     }
94327   }
94328
94329   jresult = (void *)result;
94330   return jresult;
94331 }
94332
94333
94334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94335   void * jresult ;
94336   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94337   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94338   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94339
94340   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94341   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94342   {
94343     try {
94344       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94345     } catch (std::out_of_range& e) {
94346       {
94347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94348       };
94349     } catch (std::exception& e) {
94350       {
94351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94352       };
94353     } catch (Dali::DaliException e) {
94354       {
94355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94356       };
94357     } catch (...) {
94358       {
94359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94360       };
94361     }
94362   }
94363
94364   jresult = (void *)result;
94365   return jresult;
94366 }
94367
94368
94369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94370   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94371
94372   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94373   {
94374     try {
94375       (arg1)->Reset();
94376     } catch (std::out_of_range& e) {
94377       {
94378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94379       };
94380     } catch (std::exception& e) {
94381       {
94382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94383       };
94384     } catch (Dali::DaliException e) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94387       };
94388     } catch (...) {
94389       {
94390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94391       };
94392     }
94393   }
94394
94395 }
94396
94397
94398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94399   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94400   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94401
94402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94403   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94404   {
94405     try {
94406       (arg1)->Reset(arg2);
94407     } catch (std::out_of_range& e) {
94408       {
94409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94410       };
94411     } catch (std::exception& e) {
94412       {
94413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94414       };
94415     } catch (Dali::DaliException e) {
94416       {
94417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94418       };
94419     } catch (...) {
94420       {
94421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94422       };
94423     }
94424   }
94425
94426 }
94427
94428
94429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94430   void * jresult ;
94431   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94432   Dali::Toolkit::Ruler *result = 0 ;
94433
94434   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94435   {
94436     try {
94437       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94438     } catch (std::out_of_range& e) {
94439       {
94440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94441       };
94442     } catch (std::exception& e) {
94443       {
94444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94445       };
94446     } catch (Dali::DaliException e) {
94447       {
94448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94449       };
94450     } catch (...) {
94451       {
94452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94453       };
94454     }
94455   }
94456
94457   jresult = (void *)result;
94458   return jresult;
94459 }
94460
94461
94462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94463   float jresult ;
94464   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94465   float arg2 ;
94466   float arg3 ;
94467   float result;
94468
94469   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94470   arg2 = (float)jarg2;
94471   arg3 = (float)jarg3;
94472   {
94473     try {
94474       result = (float)(*arg1)->Snap(arg2,arg3);
94475     } catch (std::out_of_range& e) {
94476       {
94477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94478       };
94479     } catch (std::exception& e) {
94480       {
94481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94482       };
94483     } catch (Dali::DaliException e) {
94484       {
94485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94486       };
94487     } catch (...) {
94488       {
94489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94490       };
94491     }
94492   }
94493
94494   jresult = result;
94495   return jresult;
94496 }
94497
94498
94499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94500   float jresult ;
94501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94502   float arg2 ;
94503   float result;
94504
94505   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94506   arg2 = (float)jarg2;
94507   {
94508     try {
94509       result = (float)(*arg1)->Snap(arg2);
94510     } catch (std::out_of_range& e) {
94511       {
94512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94513       };
94514     } catch (std::exception& e) {
94515       {
94516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94517       };
94518     } catch (Dali::DaliException e) {
94519       {
94520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94521       };
94522     } catch (...) {
94523       {
94524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94525       };
94526     }
94527   }
94528
94529   jresult = result;
94530   return jresult;
94531 }
94532
94533
94534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94535   float jresult ;
94536   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94537   unsigned int arg2 ;
94538   unsigned int *arg3 = 0 ;
94539   bool arg4 ;
94540   float result;
94541
94542   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94543   arg2 = (unsigned int)jarg2;
94544   arg3 = (unsigned int *)jarg3;
94545   arg4 = jarg4 ? true : false;
94546   {
94547     try {
94548       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94549     } catch (std::out_of_range& e) {
94550       {
94551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94552       };
94553     } catch (std::exception& e) {
94554       {
94555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94556       };
94557     } catch (Dali::DaliException e) {
94558       {
94559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94560       };
94561     } catch (...) {
94562       {
94563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94564       };
94565     }
94566   }
94567
94568   jresult = result;
94569   return jresult;
94570 }
94571
94572
94573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94574   unsigned int jresult ;
94575   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94576   float arg2 ;
94577   bool arg3 ;
94578   unsigned int result;
94579
94580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94581   arg2 = (float)jarg2;
94582   arg3 = jarg3 ? true : false;
94583   {
94584     try {
94585       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94586     } catch (std::out_of_range& e) {
94587       {
94588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94589       };
94590     } catch (std::exception& e) {
94591       {
94592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94593       };
94594     } catch (Dali::DaliException e) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94597       };
94598     } catch (...) {
94599       {
94600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94601       };
94602     }
94603   }
94604
94605   jresult = result;
94606   return jresult;
94607 }
94608
94609
94610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94611   unsigned int jresult ;
94612   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94613   unsigned int result;
94614
94615   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94616   {
94617     try {
94618       result = (unsigned int)(*arg1)->GetTotalPages();
94619     } catch (std::out_of_range& e) {
94620       {
94621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94622       };
94623     } catch (std::exception& e) {
94624       {
94625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94626       };
94627     } catch (Dali::DaliException e) {
94628       {
94629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94630       };
94631     } catch (...) {
94632       {
94633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94634       };
94635     }
94636   }
94637
94638   jresult = result;
94639   return jresult;
94640 }
94641
94642
94643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94644   int jresult ;
94645   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94646   Dali::Toolkit::Ruler::RulerType result;
94647
94648   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94649   {
94650     try {
94651       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94652     } catch (std::out_of_range& e) {
94653       {
94654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94655       };
94656     } catch (std::exception& e) {
94657       {
94658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94659       };
94660     } catch (Dali::DaliException e) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94663       };
94664     } catch (...) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94667       };
94668     }
94669   }
94670
94671   jresult = (int)result;
94672   return jresult;
94673 }
94674
94675
94676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94677   unsigned int jresult ;
94678   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94679   bool result;
94680
94681   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94682   {
94683     try {
94684       result = (bool)(*arg1)->IsEnabled();
94685     } catch (std::out_of_range& e) {
94686       {
94687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94688       };
94689     } catch (std::exception& e) {
94690       {
94691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94692       };
94693     } catch (Dali::DaliException e) {
94694       {
94695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94696       };
94697     } catch (...) {
94698       {
94699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94700       };
94701     }
94702   }
94703
94704   jresult = result;
94705   return jresult;
94706 }
94707
94708
94709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94710   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94711
94712   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94713   {
94714     try {
94715       (*arg1)->Enable();
94716     } catch (std::out_of_range& e) {
94717       {
94718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94719       };
94720     } catch (std::exception& e) {
94721       {
94722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94723       };
94724     } catch (Dali::DaliException e) {
94725       {
94726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94727       };
94728     } catch (...) {
94729       {
94730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94731       };
94732     }
94733   }
94734
94735 }
94736
94737
94738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94739   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94740
94741   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94742   {
94743     try {
94744       (*arg1)->Disable();
94745     } catch (std::out_of_range& e) {
94746       {
94747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94748       };
94749     } catch (std::exception& e) {
94750       {
94751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94752       };
94753     } catch (Dali::DaliException e) {
94754       {
94755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94756       };
94757     } catch (...) {
94758       {
94759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94760       };
94761     }
94762   }
94763
94764 }
94765
94766
94767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94768   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94769   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94770   Dali::Toolkit::RulerDomain *argp2 ;
94771
94772   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94773   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94774   if (!argp2) {
94775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94776     return ;
94777   }
94778   arg2 = *argp2;
94779   {
94780     try {
94781       (*arg1)->SetDomain(arg2);
94782     } catch (std::out_of_range& e) {
94783       {
94784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94785       };
94786     } catch (std::exception& e) {
94787       {
94788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94789       };
94790     } catch (Dali::DaliException e) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94793       };
94794     } catch (...) {
94795       {
94796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94797       };
94798     }
94799   }
94800
94801 }
94802
94803
94804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94805   void * jresult ;
94806   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94807   Dali::Toolkit::RulerDomain *result = 0 ;
94808
94809   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94810   {
94811     try {
94812       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94813     } catch (std::out_of_range& e) {
94814       {
94815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94816       };
94817     } catch (std::exception& e) {
94818       {
94819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94820       };
94821     } catch (Dali::DaliException e) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94824       };
94825     } catch (...) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94828       };
94829     }
94830   }
94831
94832   jresult = (void *)result;
94833   return jresult;
94834 }
94835
94836
94837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94838   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94839
94840   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94841   {
94842     try {
94843       (*arg1)->DisableDomain();
94844     } catch (std::out_of_range& e) {
94845       {
94846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94847       };
94848     } catch (std::exception& e) {
94849       {
94850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94851       };
94852     } catch (Dali::DaliException e) {
94853       {
94854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94855       };
94856     } catch (...) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94859       };
94860     }
94861   }
94862
94863 }
94864
94865
94866 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94867   float jresult ;
94868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94869   float arg2 ;
94870   float arg3 ;
94871   float arg4 ;
94872   float result;
94873
94874   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94875   arg2 = (float)jarg2;
94876   arg3 = (float)jarg3;
94877   arg4 = (float)jarg4;
94878   {
94879     try {
94880       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94881     } catch (std::out_of_range& e) {
94882       {
94883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94884       };
94885     } catch (std::exception& e) {
94886       {
94887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94888       };
94889     } catch (Dali::DaliException e) {
94890       {
94891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94892       };
94893     } catch (...) {
94894       {
94895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94896       };
94897     }
94898   }
94899
94900   jresult = result;
94901   return jresult;
94902 }
94903
94904
94905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94906   float jresult ;
94907   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94908   float arg2 ;
94909   float arg3 ;
94910   float result;
94911
94912   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94913   arg2 = (float)jarg2;
94914   arg3 = (float)jarg3;
94915   {
94916     try {
94917       result = (float)(*arg1)->Clamp(arg2,arg3);
94918     } catch (std::out_of_range& e) {
94919       {
94920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94921       };
94922     } catch (std::exception& e) {
94923       {
94924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94925       };
94926     } catch (Dali::DaliException e) {
94927       {
94928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94929       };
94930     } catch (...) {
94931       {
94932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94933       };
94934     }
94935   }
94936
94937   jresult = result;
94938   return jresult;
94939 }
94940
94941
94942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94943   float jresult ;
94944   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94945   float arg2 ;
94946   float result;
94947
94948   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94949   arg2 = (float)jarg2;
94950   {
94951     try {
94952       result = (float)(*arg1)->Clamp(arg2);
94953     } catch (std::out_of_range& e) {
94954       {
94955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94956       };
94957     } catch (std::exception& e) {
94958       {
94959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94960       };
94961     } catch (Dali::DaliException e) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94964       };
94965     } catch (...) {
94966       {
94967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94968       };
94969     }
94970   }
94971
94972   jresult = result;
94973   return jresult;
94974 }
94975
94976
94977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94978   float jresult ;
94979   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94980   float arg2 ;
94981   float arg3 ;
94982   float arg4 ;
94983   Dali::Toolkit::ClampState *arg5 = 0 ;
94984   float result;
94985
94986   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94987   arg2 = (float)jarg2;
94988   arg3 = (float)jarg3;
94989   arg4 = (float)jarg4;
94990   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94991   if (!arg5) {
94992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94993     return 0;
94994   }
94995   {
94996     try {
94997       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94998     } catch (std::out_of_range& e) {
94999       {
95000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95001       };
95002     } catch (std::exception& e) {
95003       {
95004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95005       };
95006     } catch (Dali::DaliException e) {
95007       {
95008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95009       };
95010     } catch (...) {
95011       {
95012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95013       };
95014     }
95015   }
95016
95017   jresult = result;
95018   return jresult;
95019 }
95020
95021
95022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
95023   float jresult ;
95024   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95025   float arg2 ;
95026   float arg3 ;
95027   float arg4 ;
95028   float arg5 ;
95029   float result;
95030
95031   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95032   arg2 = (float)jarg2;
95033   arg3 = (float)jarg3;
95034   arg4 = (float)jarg4;
95035   arg5 = (float)jarg5;
95036   {
95037     try {
95038       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
95039     } catch (std::out_of_range& e) {
95040       {
95041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95042       };
95043     } catch (std::exception& e) {
95044       {
95045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95046       };
95047     } catch (Dali::DaliException e) {
95048       {
95049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95050       };
95051     } catch (...) {
95052       {
95053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95054       };
95055     }
95056   }
95057
95058   jresult = result;
95059   return jresult;
95060 }
95061
95062
95063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
95064   float jresult ;
95065   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95066   float arg2 ;
95067   float arg3 ;
95068   float arg4 ;
95069   float result;
95070
95071   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95072   arg2 = (float)jarg2;
95073   arg3 = (float)jarg3;
95074   arg4 = (float)jarg4;
95075   {
95076     try {
95077       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95078     } catch (std::out_of_range& e) {
95079       {
95080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95081       };
95082     } catch (std::exception& e) {
95083       {
95084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95085       };
95086     } catch (Dali::DaliException e) {
95087       {
95088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95089       };
95090     } catch (...) {
95091       {
95092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95093       };
95094     }
95095   }
95096
95097   jresult = result;
95098   return jresult;
95099 }
95100
95101
95102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95103   float jresult ;
95104   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95105   float arg2 ;
95106   float arg3 ;
95107   float result;
95108
95109   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95110   arg2 = (float)jarg2;
95111   arg3 = (float)jarg3;
95112   {
95113     try {
95114       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95115     } catch (std::out_of_range& e) {
95116       {
95117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95118       };
95119     } catch (std::exception& e) {
95120       {
95121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95122       };
95123     } catch (Dali::DaliException e) {
95124       {
95125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95126       };
95127     } catch (...) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95130       };
95131     }
95132   }
95133
95134   jresult = result;
95135   return jresult;
95136 }
95137
95138
95139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95140   float jresult ;
95141   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95142   float arg2 ;
95143   float result;
95144
95145   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95146   arg2 = (float)jarg2;
95147   {
95148     try {
95149       result = (float)(*arg1)->SnapAndClamp(arg2);
95150     } catch (std::out_of_range& e) {
95151       {
95152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95153       };
95154     } catch (std::exception& e) {
95155       {
95156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95157       };
95158     } catch (Dali::DaliException e) {
95159       {
95160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95161       };
95162     } catch (...) {
95163       {
95164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95165       };
95166     }
95167   }
95168
95169   jresult = result;
95170   return jresult;
95171 }
95172
95173
95174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95175   float jresult ;
95176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95177   float arg2 ;
95178   float arg3 ;
95179   float arg4 ;
95180   float arg5 ;
95181   Dali::Toolkit::ClampState *arg6 = 0 ;
95182   float result;
95183
95184   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95185   arg2 = (float)jarg2;
95186   arg3 = (float)jarg3;
95187   arg4 = (float)jarg4;
95188   arg5 = (float)jarg5;
95189   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95190   if (!arg6) {
95191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95192     return 0;
95193   }
95194   {
95195     try {
95196       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95197     } catch (std::out_of_range& e) {
95198       {
95199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95200       };
95201     } catch (std::exception& e) {
95202       {
95203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95204       };
95205     } catch (Dali::DaliException e) {
95206       {
95207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95208       };
95209     } catch (...) {
95210       {
95211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95212       };
95213     }
95214   }
95215
95216   jresult = result;
95217   return jresult;
95218 }
95219
95220
95221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95222   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95223
95224   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95225   {
95226     try {
95227       (*arg1)->Reference();
95228     } catch (std::out_of_range& e) {
95229       {
95230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95231       };
95232     } catch (std::exception& e) {
95233       {
95234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95235       };
95236     } catch (Dali::DaliException e) {
95237       {
95238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95239       };
95240     } catch (...) {
95241       {
95242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95243       };
95244     }
95245   }
95246
95247 }
95248
95249
95250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95251   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95252
95253   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95254   {
95255     try {
95256       (*arg1)->Unreference();
95257     } catch (std::out_of_range& e) {
95258       {
95259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95260       };
95261     } catch (std::exception& e) {
95262       {
95263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95264       };
95265     } catch (Dali::DaliException e) {
95266       {
95267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95268       };
95269     } catch (...) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95272       };
95273     }
95274   }
95275
95276 }
95277
95278
95279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95280   int jresult ;
95281   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95282   int result;
95283
95284   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95285   {
95286     try {
95287       result = (int)(*arg1)->ReferenceCount();
95288     } catch (std::out_of_range& e) {
95289       {
95290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95291       };
95292     } catch (std::exception& e) {
95293       {
95294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95295       };
95296     } catch (Dali::DaliException e) {
95297       {
95298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95299       };
95300     } catch (...) {
95301       {
95302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95303       };
95304     }
95305   }
95306
95307   jresult = result;
95308   return jresult;
95309 }
95310
95311
95312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95313   unsigned int jresult ;
95314   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95315   bool result;
95316
95317   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95318   {
95319     try {
95320       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95321     } catch (std::out_of_range& e) {
95322       {
95323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95324       };
95325     } catch (std::exception& e) {
95326       {
95327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95328       };
95329     } catch (Dali::DaliException e) {
95330       {
95331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95332       };
95333     } catch (...) {
95334       {
95335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95336       };
95337     }
95338   }
95339
95340   jresult = result;
95341   return jresult;
95342 }
95343
95344
95345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95346   unsigned long jresult ;
95347   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95348   std::size_t result;
95349
95350   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95351   {
95352     try {
95353       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95354     } catch (std::out_of_range& e) {
95355       {
95356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95357       };
95358     } catch (std::exception& e) {
95359       {
95360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95361       };
95362     } catch (Dali::DaliException e) {
95363       {
95364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95365       };
95366     } catch (...) {
95367       {
95368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95369       };
95370     }
95371   }
95372
95373   jresult = (unsigned long)result;
95374   return jresult;
95375 }
95376
95377
95378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95379   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95380   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95381
95382   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95383   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95384   {
95385     try {
95386       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95387     } catch (std::out_of_range& e) {
95388       {
95389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95390       };
95391     } catch (std::exception& e) {
95392       {
95393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95394       };
95395     } catch (Dali::DaliException e) {
95396       {
95397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95398       };
95399     } catch (...) {
95400       {
95401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95402       };
95403     }
95404   }
95405
95406 }
95407
95408
95409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95410   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95411   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95412
95413   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95414   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95415   {
95416     try {
95417       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95418     } catch (std::out_of_range& e) {
95419       {
95420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95421       };
95422     } catch (std::exception& e) {
95423       {
95424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95425       };
95426     } catch (Dali::DaliException e) {
95427       {
95428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95429       };
95430     } catch (...) {
95431       {
95432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95433       };
95434     }
95435   }
95436
95437 }
95438
95439
95440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95441   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95442   Dali::Toolkit::Control arg2 ;
95443   Dali::Toolkit::Control *argp2 ;
95444
95445   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95446   argp2 = (Dali::Toolkit::Control *)jarg2;
95447   if (!argp2) {
95448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95449     return ;
95450   }
95451   arg2 = *argp2;
95452   {
95453     try {
95454       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95455     } catch (std::out_of_range& e) {
95456       {
95457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95458       };
95459     } catch (std::exception& e) {
95460       {
95461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95462       };
95463     } catch (Dali::DaliException e) {
95464       {
95465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95466       };
95467     } catch (...) {
95468       {
95469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95470       };
95471     }
95472   }
95473
95474 }
95475
95476
95477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95478   void * jresult ;
95479   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95480
95481   {
95482     try {
95483       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95484     } catch (std::out_of_range& e) {
95485       {
95486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95487       };
95488     } catch (std::exception& e) {
95489       {
95490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95491       };
95492     } catch (Dali::DaliException e) {
95493       {
95494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95495       };
95496     } catch (...) {
95497       {
95498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95499       };
95500     }
95501   }
95502
95503   jresult = (void *)result;
95504   return jresult;
95505 }
95506
95507
95508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95509   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95510
95511   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95512   {
95513     try {
95514       delete arg1;
95515     } catch (std::out_of_range& e) {
95516       {
95517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95518       };
95519     } catch (std::exception& e) {
95520       {
95521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95522       };
95523     } catch (Dali::DaliException e) {
95524       {
95525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95526       };
95527     } catch (...) {
95528       {
95529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95530       };
95531     }
95532   }
95533
95534 }
95535
95536 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95537   Dali::RefObject *result = NULL;
95538
95539   if (arg1)
95540   {
95541     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95542   }
95543   return result;
95544 }
95545
95546 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95547     return (Dali::RefObject *)jarg1;
95548 }
95549
95550 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95551     return (Dali::SignalObserver *)jarg1;
95552 }
95553
95554 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95555     return (Dali::ConnectionTrackerInterface *)jarg1;
95556 }
95557
95558 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95559     return (Dali::BaseHandle *)jarg1;
95560 }
95561
95562 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95563     return (Dali::BaseHandle *)jarg1;
95564 }
95565
95566 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95567     return (Dali::BaseHandle *)jarg1;
95568 }
95569
95570 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95571     return (Dali::BaseHandle *)jarg1;
95572 }
95573
95574 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95575     return (Dali::BaseHandle *)jarg1;
95576 }
95577
95578 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95579     return (Dali::BaseHandle *)jarg1;
95580 }
95581
95582 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95583     return (Dali::BaseHandle *)jarg1;
95584 }
95585
95586 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95587     return (Dali::BaseHandle *)jarg1;
95588 }
95589
95590 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95591     return (Dali::BaseHandle *)jarg1;
95592 }
95593
95594 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95595     return (Dali::BaseHandle *)jarg1;
95596 }
95597
95598 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95599     return (Dali::BaseHandle *)jarg1;
95600 }
95601
95602 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95603     return (Dali::BaseHandle *)jarg1;
95604 }
95605
95606 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95607     return (Dali::Handle *)jarg1;
95608 }
95609
95610 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95611     return (Dali::Handle *)jarg1;
95612 }
95613
95614 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95615     return (Dali::BaseHandle *)jarg1;
95616 }
95617
95618 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95619     return (Dali::BaseHandle *)jarg1;
95620 }
95621
95622 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95623     return (Dali::Handle *)jarg1;
95624 }
95625
95626 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
95627     return (Dali::BaseHandle *)jarg1;
95628 }
95629
95630 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95631     return (Dali::BaseHandle *)jarg1;
95632 }
95633
95634 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95635     return (Dali::Handle *)jarg1;
95636 }
95637
95638 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95639     return (Dali::GestureDetector *)jarg1;
95640 }
95641
95642 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95643     return (Dali::Gesture *)jarg1;
95644 }
95645
95646 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95647     return (Dali::Handle *)jarg1;
95648 }
95649
95650 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95651     return (Dali::Actor *)jarg1;
95652 }
95653
95654 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95655     return (Dali::RefObject *)jarg1;
95656 }
95657
95658 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95659     return (Dali::Actor *)jarg1;
95660 }
95661
95662 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95663     return (Dali::GestureDetector *)jarg1;
95664 }
95665
95666 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95667     return (Dali::Gesture *)jarg1;
95668 }
95669
95670 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95671     return (Dali::GestureDetector *)jarg1;
95672 }
95673
95674 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95675     return (Dali::Gesture *)jarg1;
95676 }
95677
95678 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95679     return (Dali::GestureDetector *)jarg1;
95680 }
95681
95682 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95683     return (Dali::Gesture *)jarg1;
95684 }
95685
95686 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95687     return (Dali::BaseHandle *)jarg1;
95688 }
95689
95690 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95691     return (Dali::Handle *)jarg1;
95692 }
95693
95694 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95695     return (Dali::Handle *)jarg1;
95696 }
95697
95698 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95699     return (Dali::Handle *)jarg1;
95700 }
95701
95702 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95703     return (Dali::RefObject *)jarg1;
95704 }
95705
95706 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95707     return (Dali::Actor *)jarg1;
95708 }
95709
95710 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95711     return (Dali::BaseHandle *)jarg1;
95712 }
95713
95714 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95715     return (Dali::BaseHandle *)jarg1;
95716 }
95717
95718 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95719     return (Dali::BaseHandle *)jarg1;
95720 }
95721
95722 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95723     return (Dali::CustomActorImpl *)jarg1;
95724 }
95725
95726 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95727     return (Dali::CustomActor *)jarg1;
95728 }
95729
95730 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95731     return (Dali::BaseHandle *)jarg1;
95732 }
95733
95734 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95735     return (Dali::Toolkit::Control *)jarg1;
95736 }
95737
95738 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95739     return (Dali::Toolkit::Control *)jarg1;
95740 }
95741
95742 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95743     return (Dali::Toolkit::Button *)jarg1;
95744 }
95745
95746 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95747     return (Dali::Toolkit::Button *)jarg1;
95748 }
95749
95750 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95751     return (Dali::Toolkit::Button *)jarg1;
95752 }
95753
95754 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95755     return (Dali::Toolkit::Control *)jarg1;
95756 }
95757
95758 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95759     return (Dali::Toolkit::Control *)jarg1;
95760 }
95761
95762 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95763     return (Dali::Toolkit::Control *)jarg1;
95764 }
95765
95766 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95767     return (Dali::Toolkit::Control *)jarg1;
95768 }
95769
95770 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95771     return (Dali::Toolkit::Control *)jarg1;
95772 }
95773
95774 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95775     return (Dali::RefObject *)jarg1;
95776 }
95777
95778 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95779     return (Dali::Toolkit::Scrollable *)jarg1;
95780 }
95781
95782 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95783     return (Dali::BaseHandle *)jarg1;
95784 }
95785
95786 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95787     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95788 }
95789
95790 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95791     return (Dali::RefObject *)jarg1;
95792 }
95793
95794 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95795     return (Dali::Toolkit::Ruler *)jarg1;
95796 }
95797
95798 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95799     return (Dali::Toolkit::Ruler *)jarg1;
95800 }
95801
95802 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95803     return (Dali::Toolkit::Scrollable *)jarg1;
95804 }
95805
95806 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95807     return (Dali::Toolkit::Control *)jarg1;
95808 }
95809
95810
95811 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95812     return (Dali::Toolkit::Control *)jarg1;
95813 }
95814
95815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95816     return (Dali::BaseHandle *)jarg1;
95817 }
95818
95819 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95820     return (Dali::BaseHandle *)jarg1;
95821 }
95822
95823 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95824     return (Dali::Toolkit::Control *)jarg1;
95825 }
95826
95827 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95828     return (Dali::Toolkit::Control *)jarg1;
95829 }
95830
95831 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95832     return (Dali::Toolkit::Control *)jarg1;
95833 }
95834
95835 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95836     return (Dali::Toolkit::Control *)jarg1;
95837 }
95838
95839 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95840     return (Dali::Toolkit::Control *)jarg1;
95841 }
95842
95843 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95844     return (Dali::Toolkit::Control *)jarg1;
95845 }
95846
95847 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95848     return (Dali::Toolkit::PageTurnView *)jarg1;
95849 }
95850
95851 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95852     return (Dali::Toolkit::PageTurnView *)jarg1;
95853 }
95854
95855 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95856     return (Dali::Toolkit::Button *)jarg1;
95857 }
95858
95859 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95860     return (Dali::BaseHandle *)jarg1;
95861 }
95862
95863 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95864     return (Dali::BaseHandle *)jarg1;
95865 }
95866
95867 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95868     return (Dali::BaseHandle *)jarg1;
95869 }
95870
95871 /*
95872  * Widget binding
95873  */
95874 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95875     return (Dali::BaseHandle *)jarg1;
95876 }
95877
95878 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95879     return (Dali::BaseObject *)jarg1;
95880 }
95881
95882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95883   void * jresult ;
95884   Dali::Widget result;
95885
95886   {
95887     try {
95888       result = Dali::Widget::New();
95889     } catch (std::out_of_range& e) {
95890       {
95891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95892       };
95893     } catch (std::exception& e) {
95894       {
95895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (...) {
95898       {
95899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95900       };
95901     }
95902   }
95903   jresult = new Dali::Widget((const Dali::Widget &)result);
95904   return jresult;
95905 }
95906
95907
95908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95909   void * jresult ;
95910   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95911   Dali::Widget result;
95912
95913   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95914
95915   if (!arg1) {
95916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95917     return 0;
95918   }
95919   {
95920     try {
95921       jresult = new Dali::Widget(arg1);
95922     } catch (std::out_of_range& e) {
95923       {
95924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95925       };
95926     } catch (std::exception& e) {
95927       {
95928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95929       };
95930     } catch (...) {
95931       {
95932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95933       };
95934     }
95935   }
95936   return jresult;
95937 }
95938
95939
95940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95941   void * jresult ;
95942   Dali::Widget *result = 0 ;
95943
95944   {
95945     try {
95946       result = (Dali::Widget *)new Dali::Widget();
95947     } catch (std::out_of_range& e) {
95948       {
95949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95950       };
95951     } catch (std::exception& e) {
95952       {
95953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95958       };
95959     }
95960   }
95961   jresult = (void *)result;
95962   return jresult;
95963 }
95964
95965
95966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95967   void * jresult ;
95968   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95969   Dali::Widget *arg2 = 0 ;
95970   Dali::Widget *result = 0 ;
95971
95972   arg1 = (Dali::Widget *)jarg1;
95973   arg2 = (Dali::Widget *)jarg2;
95974   if (!arg2) {
95975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95976     return 0;
95977   }
95978   {
95979     try {
95980       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95981     } catch (std::out_of_range& e) {
95982       {
95983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95984       };
95985     } catch (std::exception& e) {
95986       {
95987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95988       };
95989     } catch (...) {
95990       {
95991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95992       };
95993     }
95994   }
95995   jresult = (void *)result;
95996   return jresult;
95997 }
95998
95999
96000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
96001   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96002
96003   arg1 = (Dali::Widget *)jarg1;
96004   {
96005     try {
96006       delete arg1;
96007     } catch (std::out_of_range& e) {
96008       {
96009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96010       };
96011     } catch (std::exception& e) {
96012       {
96013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96014       };
96015     } catch (...) {
96016       {
96017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96018       };
96019     }
96020   }
96021 }
96022
96023
96024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
96025   void * jresult ;
96026   SwigDirector_WidgetImpl* result;
96027   {
96028     try {
96029       result = new SwigDirector_WidgetImpl();
96030     } catch (std::out_of_range& e) {
96031       {
96032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96033       };
96034     } catch (std::exception& e) {
96035       {
96036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96037       };
96038     } catch (...) {
96039       {
96040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96041       };
96042     }
96043   }
96044   jresult = result;
96045   return jresult;
96046 }
96047
96048
96049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
96050   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96051   std::string *arg2 = 0 ;
96052   Dali::Window arg3 ;
96053   Dali::Window *argp3 ;
96054
96055   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96056   if (!jarg2) {
96057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96058     return ;
96059   }
96060   std::string arg2_str(jarg2);
96061   arg2 = &arg2_str;
96062   argp3 = (Dali::Window *)jarg3;
96063   if (!argp3) {
96064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96065     return ;
96066   }
96067   arg3 = *argp3;
96068   {
96069     try {
96070       (arg1)->OnCreate((std::string const &)*arg2,arg3);
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 (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085 }
96086
96087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96088   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96089   std::string *arg2 = 0 ;
96090   Dali::Window arg3 ;
96091   Dali::Window *argp3 ;
96092
96093   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96094   if (!jarg2) {
96095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96096     return ;
96097   }
96098   std::string arg2_str(jarg2);
96099   arg2 = &arg2_str;
96100   argp3 = (Dali::Window *)jarg3;
96101   if (!argp3) {
96102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96103     return ;
96104   }
96105   arg3 = *argp3;
96106   {
96107     try {
96108       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96109     } catch (std::out_of_range& e) {
96110       {
96111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96112       };
96113     } catch (std::exception& e) {
96114       {
96115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96116       };
96117     } catch (...) {
96118       {
96119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96120       };
96121     }
96122   }
96123 }
96124
96125
96126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96127   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96128   std::string *arg2 = 0 ;
96129   Dali::Widget::Termination arg3 ;
96130
96131   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96132   if (!jarg2) {
96133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96134     return ;
96135   }
96136   std::string arg2_str(jarg2);
96137   arg2 = &arg2_str;
96138   arg3 = (Dali::Widget::Termination)jarg3;
96139   {
96140     try {
96141       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96142     } catch (std::out_of_range& e) {
96143       {
96144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96145       };
96146     } catch (std::exception& e) {
96147       {
96148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96149       };
96150     } catch (...) {
96151       {
96152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96153       };
96154     }
96155   }
96156 }
96157
96158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96159   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96160   std::string *arg2 = 0 ;
96161   Dali::Widget::Termination arg3 ;
96162
96163   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96164   if (!jarg2) {
96165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96166     return ;
96167   }
96168   std::string arg2_str(jarg2);
96169   arg2 = &arg2_str;
96170   arg3 = (Dali::Widget::Termination)jarg3;
96171   {
96172     try {
96173       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96174     } catch (std::out_of_range& e) {
96175       {
96176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96177       };
96178     } catch (std::exception& e) {
96179       {
96180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96181       };
96182     } catch (...) {
96183       {
96184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96185       };
96186     }
96187   }
96188 }
96189
96190
96191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96192   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96193
96194   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96195   {
96196     try {
96197       (arg1)->OnPause();
96198     } catch (std::out_of_range& e) {
96199       {
96200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96201       };
96202     } catch (std::exception& e) {
96203       {
96204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96205       };
96206     } catch (...) {
96207       {
96208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96209       };
96210     }
96211   }
96212 }
96213
96214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96215   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96216
96217   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96218   {
96219     try {
96220       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96221     } catch (std::out_of_range& e) {
96222       {
96223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96224       };
96225     } catch (std::exception& e) {
96226       {
96227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96228       };
96229     } catch (...) {
96230       {
96231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96232       };
96233     }
96234   }
96235 }
96236
96237
96238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96239   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96240
96241   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96242   {
96243     try {
96244       (arg1)->OnResume();
96245     } catch (std::out_of_range& e) {
96246       {
96247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96248       };
96249     } catch (std::exception& e) {
96250       {
96251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96252       };
96253     } catch (...) {
96254       {
96255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96256       };
96257     }
96258   }
96259 }
96260
96261
96262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96263   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96264
96265   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96266   {
96267     try {
96268       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96269     } catch (std::out_of_range& e) {
96270       {
96271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96272       };
96273     } catch (std::exception& e) {
96274       {
96275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96276       };
96277     } catch (...) {
96278       {
96279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96280       };
96281     }
96282   }
96283 }
96284
96285
96286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96287   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96288   Dali::Window arg2 ;
96289   Dali::Window *argp2 ;
96290
96291   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96292   argp2 = (Dali::Window *)jarg2;
96293   if (!argp2) {
96294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96295     return ;
96296   }
96297   arg2 = *argp2;
96298   {
96299     try {
96300       (arg1)->OnResize(arg2);
96301     } catch (std::out_of_range& e) {
96302       {
96303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96304       };
96305     } catch (std::exception& e) {
96306       {
96307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96308       };
96309     } catch (...) {
96310       {
96311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96312       };
96313     }
96314   }
96315 }
96316
96317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96318   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96319   Dali::Window arg2 ;
96320   Dali::Window *argp2 ;
96321
96322   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96323   argp2 = (Dali::Window *)jarg2;
96324   if (!argp2) {
96325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96326     return ;
96327   }
96328   arg2 = *argp2;
96329   {
96330     try {
96331       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96332     } catch (std::out_of_range& e) {
96333       {
96334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96335       };
96336     } catch (std::exception& e) {
96337       {
96338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96339       };
96340     } catch (...) {
96341       {
96342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96343       };
96344     }
96345   }
96346 }
96347
96348
96349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96350   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96351   std::string *arg2 = 0 ;
96352   int arg3 ;
96353
96354   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96355   if (!jarg2) {
96356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96357     return ;
96358   }
96359   std::string arg2_str(jarg2);
96360   arg2 = &arg2_str;
96361   arg3 = (int)jarg3;
96362   {
96363     try {
96364       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96365     } catch (std::out_of_range& e) {
96366       {
96367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96368       };
96369     } catch (std::exception& e) {
96370       {
96371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96372       };
96373     } catch (...) {
96374       {
96375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96376       };
96377     }
96378   }
96379 }
96380
96381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96382   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96383   std::string *arg2 = 0 ;
96384   int arg3 ;
96385
96386   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96387   if (!jarg2) {
96388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96389     return ;
96390   }
96391   std::string arg2_str(jarg2);
96392   arg2 = &arg2_str;
96393   arg3 = (int)jarg3;
96394   {
96395     try {
96396       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96397     } catch (std::out_of_range& e) {
96398       {
96399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96400       };
96401     } catch (std::exception& e) {
96402       {
96403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96404       };
96405     } catch (...) {
96406       {
96407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96408       };
96409     }
96410   }
96411 }
96412
96413
96414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96415   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96416   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96417   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96418
96419   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96420   arg2 = (Dali::SlotObserver *)jarg2;
96421   arg3 = (Dali::CallbackBase *)jarg3;
96422   {
96423     try {
96424       (arg1)->SignalConnected(arg2,arg3);
96425     } catch (std::out_of_range& e) {
96426       {
96427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96428       };
96429     } catch (std::exception& e) {
96430       {
96431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96432       };
96433     } catch (...) {
96434       {
96435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96436       };
96437     }
96438   }
96439 }
96440
96441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96442   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96443   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96444   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96445
96446   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96447   arg2 = (Dali::SlotObserver *)jarg2;
96448   arg3 = (Dali::CallbackBase *)jarg3;
96449   {
96450     try {
96451       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96452     } catch (std::out_of_range& e) {
96453       {
96454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96455       };
96456     } catch (std::exception& e) {
96457       {
96458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96459       };
96460     } catch (...) {
96461       {
96462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96463       };
96464     }
96465   }
96466 }
96467
96468
96469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96470   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96471   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96472   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96473
96474   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96475   arg2 = (Dali::SlotObserver *)jarg2;
96476   arg3 = (Dali::CallbackBase *)jarg3;
96477   {
96478     try {
96479       (arg1)->SignalDisconnected(arg2,arg3);
96480     } catch (std::out_of_range& e) {
96481       {
96482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96483       };
96484     } catch (std::exception& e) {
96485       {
96486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96487       };
96488     } catch (...) {
96489       {
96490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96491       };
96492     }
96493   }
96494 }
96495
96496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96497   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96498   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96499   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96500
96501   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96502   arg2 = (Dali::SlotObserver *)jarg2;
96503   arg3 = (Dali::CallbackBase *)jarg3;
96504   {
96505     try {
96506       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96507     } catch (std::out_of_range& e) {
96508       {
96509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96510       };
96511     } catch (std::exception& e) {
96512       {
96513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96514       };
96515     } catch (...) {
96516       {
96517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96518       };
96519     }
96520   }
96521 }
96522
96523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96524   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96525   std::string *arg2 = 0 ;
96526
96527   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96528   if (!jarg2) {
96529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96530     return ;
96531   }
96532   std::string arg2_str(jarg2);
96533   arg2 = &arg2_str;
96534   {
96535     try {
96536       (arg1)->SetContentInfo((std::string const &)*arg2);
96537     } catch (std::out_of_range& e) {
96538       {
96539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96540       };
96541     } catch (std::exception& e) {
96542       {
96543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96544       };
96545     } catch (...) {
96546       {
96547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96548       };
96549     }
96550   }
96551 }
96552
96553
96554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96555   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96556   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96557
96558   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96559   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96560   {
96561     try {
96562       (arg1)->SetImpl(arg2);
96563     } catch (std::out_of_range& e) {
96564       {
96565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96566       };
96567     } catch (std::exception& e) {
96568       {
96569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96570       };
96571     } catch (...) {
96572       {
96573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96574       };
96575     }
96576   }
96577 }
96578
96579 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) {
96580
96581   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96582   if (director) {
96583     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96584   }
96585 }
96586
96587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96588   void * jresult ;
96589   Dali::Widget *arg1 = 0 ;
96590   SwigDirector_WidgetImpl *result = 0 ;
96591
96592   arg1 = (Dali::Widget *)jarg1;
96593   if (!arg1) {
96594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96595     return 0;
96596   }
96597   {
96598     try {
96599       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96600     } catch (std::out_of_range& e) {
96601       {
96602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96603       };
96604     } catch (std::exception& e) {
96605       {
96606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96607       };
96608     } catch (...) {
96609       {
96610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96611       };
96612     }
96613   }
96614
96615   jresult = (void *)result;
96616   return jresult;
96617 }
96618
96619
96620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96621   void * jresult ;
96622   int *arg1 = (int *) 0 ;
96623   char ***arg2 ;
96624   std::string *arg3 = 0 ;
96625   Dali::WidgetApplication result;
96626   {
96627     int index = 0;
96628     int length = 0;
96629     char *retPtr;
96630     char *nextPtr;
96631     argWidgetC = jarg1;
96632     argWidgetV = new char*[jarg1 + 1];
96633
96634     retPtr = strtok_r( jarg2, " ", &nextPtr);
96635     if( retPtr )
96636     {
96637       length = strlen(retPtr);
96638     }
96639     argWidgetV[index] = new char[length + 1];
96640     if( retPtr )
96641     {
96642       strncpy(argWidgetV[index], retPtr, length);
96643     }
96644     argWidgetV[index][length] = '\0';
96645     index++;
96646
96647     while (index < jarg1)
96648     {
96649       length = 0;
96650       retPtr = strtok_r(NULL, " ", &nextPtr);
96651       if( retPtr )
96652       {
96653         length = strlen(retPtr);
96654       }
96655       argWidgetV[index] = new char[length + 1];
96656       if( retPtr )
96657       {
96658         strncpy(argWidgetV[index], retPtr, length);
96659       }
96660       argWidgetV[index][length] = '\0';
96661       index++;
96662     }
96663
96664     argWidgetV[jarg1] = NULL;
96665     argWidgetC = jarg1;
96666
96667     arg1 = &argWidgetC;
96668     arg2 = &argWidgetV;
96669   }
96670
96671   if (!jarg3) {
96672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96673     return 0;
96674   }
96675   std::string arg3_str(jarg3);
96676   arg3 = &arg3_str;
96677   {
96678     try {
96679       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96680     } catch (std::out_of_range& e) {
96681       {
96682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96683       };
96684     } catch (std::exception& e) {
96685       {
96686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96687       };
96688     } catch (...) {
96689       {
96690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96691       };
96692     }
96693   }
96694   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96695
96696   return jresult;
96697 }
96698
96699
96700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96701   void * jresult ;
96702   Dali::WidgetApplication *result = 0 ;
96703
96704   {
96705     try {
96706       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96707     } catch (std::out_of_range& e) {
96708       {
96709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96710       };
96711     } catch (std::exception& e) {
96712       {
96713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96714       };
96715     } catch (...) {
96716       {
96717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96718       };
96719     }
96720   }
96721   jresult = (void *)result;
96722   return jresult;
96723 }
96724
96725
96726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96727   void * jresult ;
96728   Dali::WidgetApplication *arg1 = 0 ;
96729   Dali::WidgetApplication *result = 0 ;
96730
96731   arg1 = (Dali::WidgetApplication *)jarg1;
96732   if (!arg1) {
96733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96734     return 0;
96735   }
96736   {
96737     try {
96738       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96739     } catch (std::out_of_range& e) {
96740       {
96741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96742       };
96743     } catch (std::exception& e) {
96744       {
96745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96746       };
96747     } catch (...) {
96748       {
96749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96750       };
96751     }
96752   }
96753   jresult = (void *)result;
96754   return jresult;
96755 }
96756
96757
96758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96759   void * jresult ;
96760   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96761   Dali::WidgetApplication *arg2 = 0 ;
96762   Dali::WidgetApplication *result = 0 ;
96763
96764   arg1 = (Dali::WidgetApplication *)jarg1;
96765   arg2 = (Dali::WidgetApplication *)jarg2;
96766   if (!arg2) {
96767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96768     return 0;
96769   }
96770   {
96771     try {
96772       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96773     } catch (std::out_of_range& e) {
96774       {
96775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96776       };
96777     } catch (std::exception& e) {
96778       {
96779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96780       };
96781     } catch (...) {
96782       {
96783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96784       };
96785     }
96786   }
96787   jresult = (void *)result;
96788   return jresult;
96789 }
96790
96791
96792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96793   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96794
96795   arg1 = (Dali::WidgetApplication *)jarg1;
96796   {
96797     try {
96798       delete arg1;
96799       if( argWidgetV )
96800       {
96801         // free string data
96802         for( int i=0; i < argWidgetC+1; i++)
96803         {
96804           delete [] argWidgetV[i];
96805         }
96806         delete [] argWidgetV;
96807       }
96808     } catch (std::out_of_range& e) {
96809       {
96810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96811       };
96812     } catch (std::exception& e) {
96813       {
96814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96815       };
96816     } catch (...) {
96817       {
96818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96819       };
96820     }
96821   }
96822 }
96823
96824
96825 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96826 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96827
96828 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96829 {
96830   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96831   return *widget;
96832 }
96833
96834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96835   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96836   std::string *arg2 = 0 ;
96837
96838   arg1 = (Dali::WidgetApplication *)jarg1;
96839   if (!jarg2) {
96840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96841     return ;
96842   }
96843   std::string arg2_str(*jarg2);
96844   arg2 = &arg2_str;
96845
96846   if(!_CSharpCreateWidgetFunction)
96847   {
96848     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96849   }
96850
96851   {
96852     try {
96853       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96854     } catch (std::out_of_range& e) {
96855       {
96856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96857       };
96858     } catch (std::exception& e) {
96859       {
96860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96861       };
96862     } catch (...) {
96863       {
96864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96865       };
96866     }
96867   }
96868
96869   //Typemap argout in c++ file.
96870   //This will convert c++ string to c# string
96871   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96872 }
96873
96874
96875 //for PixelBuffer and ImageLoading
96876
96877 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96878     return (Dali::BaseHandle *)jarg1;
96879 }
96880
96881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96882   void * jresult ;
96883   unsigned int arg1 ;
96884   unsigned int arg2 ;
96885   Dali::Pixel::Format arg3 ;
96886   Dali::Devel::PixelBuffer result;
96887
96888   arg1 = (unsigned int)jarg1;
96889   arg2 = (unsigned int)jarg2;
96890   arg3 = (Dali::Pixel::Format)jarg3;
96891   {
96892     try {
96893       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96894     } catch (std::out_of_range& e) {
96895       {
96896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96897       };
96898     } catch (std::exception& e) {
96899       {
96900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96905       };
96906     }
96907   }
96908   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96909   return jresult;
96910 }
96911
96912
96913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96914   void * jresult ;
96915   Dali::Devel::PixelBuffer *result = 0 ;
96916
96917   {
96918     try {
96919       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96920     } catch (std::out_of_range& e) {
96921       {
96922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96923       };
96924     } catch (std::exception& e) {
96925       {
96926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96927       };
96928     } catch (...) {
96929       {
96930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96931       };
96932     }
96933   }
96934   jresult = (void *)result;
96935   return jresult;
96936 }
96937
96938
96939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96940   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96941
96942   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96943   {
96944     try {
96945       delete arg1;
96946     } catch (std::out_of_range& e) {
96947       {
96948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96949       };
96950     } catch (std::exception& e) {
96951       {
96952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96953       };
96954     } catch (...) {
96955       {
96956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96957       };
96958     }
96959   }
96960 }
96961
96962
96963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96964   void * jresult ;
96965   Dali::Devel::PixelBuffer *arg1 = 0 ;
96966   Dali::Devel::PixelBuffer *result = 0 ;
96967
96968   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96969   if (!arg1) {
96970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96971     return 0;
96972   }
96973   {
96974     try {
96975       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96976     } catch (std::out_of_range& e) {
96977       {
96978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96979       };
96980     } catch (std::exception& e) {
96981       {
96982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96983       };
96984     } catch (...) {
96985       {
96986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96987       };
96988     }
96989   }
96990   jresult = (void *)result;
96991   return jresult;
96992 }
96993
96994
96995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96996   void * jresult ;
96997   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96998   Dali::Devel::PixelBuffer *arg2 = 0 ;
96999   Dali::Devel::PixelBuffer *result = 0 ;
97000
97001   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97002   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
97003   if (!arg2) {
97004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97005     return 0;
97006   }
97007   {
97008     try {
97009       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
97010     } catch (std::out_of_range& e) {
97011       {
97012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97013       };
97014     } catch (std::exception& e) {
97015       {
97016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97017       };
97018     } catch (...) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97021       };
97022     }
97023   }
97024   jresult = (void *)result;
97025   return jresult;
97026 }
97027
97028
97029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
97030   void * jresult ;
97031   Dali::Devel::PixelBuffer *arg1 = 0 ;
97032   Dali::PixelData result;
97033
97034   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97035   if (!arg1) {
97036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
97037     return 0;
97038   }
97039   {
97040     try {
97041       result = Dali::Devel::PixelBuffer::Convert(*arg1);
97042     } catch (std::out_of_range& e) {
97043       {
97044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97045       };
97046     } catch (std::exception& e) {
97047       {
97048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97049       };
97050     } catch (...) {
97051       {
97052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97053       };
97054     }
97055   }
97056   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97057   return jresult;
97058 }
97059
97060
97061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
97062   void * jresult ;
97063   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97064   Dali::PixelData result;
97065
97066   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97067   {
97068     try {
97069       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97070     } catch (std::out_of_range& e) {
97071       {
97072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97073       };
97074     } catch (std::exception& e) {
97075       {
97076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97077       };
97078     } catch (...) {
97079       {
97080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97081       };
97082     }
97083   }
97084   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97085   return jresult;
97086 }
97087
97088
97089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97090   void * jresult ;
97091   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97092   unsigned char *result = 0 ;
97093
97094   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97095   {
97096     try {
97097       result = (unsigned char *)(arg1)->GetBuffer();
97098     } catch (std::out_of_range& e) {
97099       {
97100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97101       };
97102     } catch (std::exception& e) {
97103       {
97104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97105       };
97106     } catch (...) {
97107       {
97108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97109       };
97110     }
97111   }
97112   jresult = (void *)result;
97113   return jresult;
97114 }
97115
97116
97117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97118   unsigned int jresult ;
97119   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97120   unsigned int result;
97121
97122   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97123   {
97124     try {
97125       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97126     } catch (std::out_of_range& e) {
97127       {
97128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97129       };
97130     } catch (std::exception& e) {
97131       {
97132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97133       };
97134     } catch (...) {
97135       {
97136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97137       };
97138     }
97139   }
97140   jresult = result;
97141   return jresult;
97142 }
97143
97144
97145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97146   unsigned int jresult ;
97147   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97148   unsigned int result;
97149
97150   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97151   {
97152     try {
97153       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97154     } catch (std::out_of_range& e) {
97155       {
97156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97157       };
97158     } catch (std::exception& e) {
97159       {
97160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97161       };
97162     } catch (...) {
97163       {
97164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97165       };
97166     }
97167   }
97168   jresult = result;
97169   return jresult;
97170 }
97171
97172
97173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97174   int jresult ;
97175   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97176   Dali::Pixel::Format result;
97177
97178   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97179   {
97180     try {
97181       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97182     } catch (std::out_of_range& e) {
97183       {
97184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97185       };
97186     } catch (std::exception& e) {
97187       {
97188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97189       };
97190     } catch (...) {
97191       {
97192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97193       };
97194     }
97195   }
97196   jresult = (int)result;
97197   return jresult;
97198 }
97199
97200
97201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97202   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97203   Dali::Devel::PixelBuffer arg2 ;
97204   float arg3 ;
97205   bool arg4 ;
97206   Dali::Devel::PixelBuffer *argp2 ;
97207
97208   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97209   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97210   if (!argp2) {
97211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97212     return ;
97213   }
97214   arg2 = *argp2;
97215   arg3 = (float)jarg3;
97216   arg4 = jarg4 ? true : false;
97217   {
97218     try {
97219       (arg1)->ApplyMask(arg2,arg3,arg4);
97220     } catch (std::out_of_range& e) {
97221       {
97222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97223       };
97224     } catch (std::exception& e) {
97225       {
97226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97227       };
97228     } catch (...) {
97229       {
97230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97231       };
97232     }
97233   }
97234 }
97235
97236
97237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97238   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97239   Dali::Devel::PixelBuffer arg2 ;
97240   float arg3 ;
97241   Dali::Devel::PixelBuffer *argp2 ;
97242
97243   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97244   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97245   if (!argp2) {
97246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97247     return ;
97248   }
97249   arg2 = *argp2;
97250   arg3 = (float)jarg3;
97251   {
97252     try {
97253       (arg1)->ApplyMask(arg2,arg3);
97254     } catch (std::out_of_range& e) {
97255       {
97256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97257       };
97258     } catch (std::exception& e) {
97259       {
97260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97261       };
97262     } catch (...) {
97263       {
97264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97265       };
97266     }
97267   }
97268 }
97269
97270
97271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97272   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97273   Dali::Devel::PixelBuffer arg2 ;
97274   Dali::Devel::PixelBuffer *argp2 ;
97275
97276   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97277   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97278   if (!argp2) {
97279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97280     return ;
97281   }
97282   arg2 = *argp2;
97283   {
97284     try {
97285       (arg1)->ApplyMask(arg2);
97286     } catch (std::out_of_range& e) {
97287       {
97288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97289       };
97290     } catch (std::exception& e) {
97291       {
97292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97293       };
97294     } catch (...) {
97295       {
97296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97297       };
97298     }
97299   }
97300 }
97301
97302
97303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97304   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97305   float arg2 ;
97306
97307   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97308   arg2 = (float)jarg2;
97309   {
97310     try {
97311       (arg1)->ApplyGaussianBlur(arg2);
97312     } catch (std::out_of_range& e) {
97313       {
97314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97315       };
97316     } catch (std::exception& e) {
97317       {
97318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97319       };
97320     } catch (...) {
97321       {
97322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97323       };
97324     }
97325   }
97326 }
97327
97328
97329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97330   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97331   uint16_t arg2 ;
97332   uint16_t arg3 ;
97333   uint16_t arg4 ;
97334   uint16_t arg5 ;
97335
97336   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97337   arg2 = (uint16_t)jarg2;
97338   arg3 = (uint16_t)jarg3;
97339   arg4 = (uint16_t)jarg4;
97340   arg5 = (uint16_t)jarg5;
97341   {
97342     try {
97343       (arg1)->Crop(arg2,arg3,arg4,arg5);
97344     } catch (std::out_of_range& e) {
97345       {
97346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97347       };
97348     } catch (std::exception& e) {
97349       {
97350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97351       };
97352     } catch (...) {
97353       {
97354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97355       };
97356     }
97357   }
97358 }
97359
97360
97361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97362   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97363   uint16_t arg2 ;
97364   uint16_t arg3 ;
97365
97366   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97367   arg2 = (uint16_t)jarg2;
97368   arg3 = (uint16_t)jarg3;
97369   {
97370     try {
97371       (arg1)->Resize(arg2,arg3);
97372     } catch (std::out_of_range& e) {
97373       {
97374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97375       };
97376     } catch (std::exception& e) {
97377       {
97378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97379       };
97380     } catch (...) {
97381       {
97382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97383       };
97384     }
97385   }
97386 }
97387
97388 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97389   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97390   Dali::Degree * arg2 ;
97391
97392   bool result = false;
97393
97394   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97395   arg2 = (Dali::Degree *)jarg2;
97396   {
97397     try {
97398       result = (arg1)->Rotate(*arg2);
97399     } catch (std::out_of_range& e) {
97400       {
97401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97402       };
97403     } catch (std::exception& e) {
97404       {
97405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97406       };
97407     } catch (...) {
97408       {
97409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97410       };
97411     }
97412   }
97413   return result;
97414 }
97415
97416
97417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97418   void * jresult ;
97419   std::string *arg1 = 0 ;
97420   Dali::ImageDimensions arg2 ;
97421   Dali::FittingMode::Type arg3 ;
97422   Dali::SamplingMode::Type arg4 ;
97423   bool arg5 ;
97424   Dali::ImageDimensions *argp2 ;
97425   Dali::Devel::PixelBuffer result;
97426
97427   if (!jarg1) {
97428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97429     return 0;
97430   }
97431   std::string arg1_str(jarg1);
97432   arg1 = &arg1_str;
97433   argp2 = (Dali::ImageDimensions *)jarg2;
97434   if (!argp2) {
97435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97436     return 0;
97437   }
97438   arg2 = *argp2;
97439   arg3 = (Dali::FittingMode::Type)jarg3;
97440   arg4 = (Dali::SamplingMode::Type)jarg4;
97441   arg5 = jarg5 ? true : false;
97442   {
97443     try {
97444       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97445     } catch (std::out_of_range& e) {
97446       {
97447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97448       };
97449     } catch (std::exception& e) {
97450       {
97451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97452       };
97453     } catch (...) {
97454       {
97455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97456       };
97457     }
97458   }
97459   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97460
97461   return jresult;
97462 }
97463
97464
97465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97466   void * jresult ;
97467   std::string *arg1 = 0 ;
97468   Dali::ImageDimensions arg2 ;
97469   Dali::FittingMode::Type arg3 ;
97470   Dali::SamplingMode::Type arg4 ;
97471   Dali::ImageDimensions *argp2 ;
97472   Dali::Devel::PixelBuffer result;
97473
97474   if (!jarg1) {
97475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97476     return 0;
97477   }
97478   std::string arg1_str(jarg1);
97479   arg1 = &arg1_str;
97480   argp2 = (Dali::ImageDimensions *)jarg2;
97481   if (!argp2) {
97482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97483     return 0;
97484   }
97485   arg2 = *argp2;
97486   arg3 = (Dali::FittingMode::Type)jarg3;
97487   arg4 = (Dali::SamplingMode::Type)jarg4;
97488   {
97489     try {
97490       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97491     } catch (std::out_of_range& e) {
97492       {
97493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97494       };
97495     } catch (std::exception& e) {
97496       {
97497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97498       };
97499     } catch (...) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97502       };
97503     }
97504   }
97505   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97506
97507   return jresult;
97508 }
97509
97510
97511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97512   void * jresult ;
97513   std::string *arg1 = 0 ;
97514   Dali::ImageDimensions arg2 ;
97515   Dali::FittingMode::Type arg3 ;
97516   Dali::ImageDimensions *argp2 ;
97517   Dali::Devel::PixelBuffer result;
97518
97519   if (!jarg1) {
97520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97521     return 0;
97522   }
97523   std::string arg1_str(jarg1);
97524   arg1 = &arg1_str;
97525   argp2 = (Dali::ImageDimensions *)jarg2;
97526   if (!argp2) {
97527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97528     return 0;
97529   }
97530   arg2 = *argp2;
97531   arg3 = (Dali::FittingMode::Type)jarg3;
97532   {
97533     try {
97534       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97535     } catch (std::out_of_range& e) {
97536       {
97537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97538       };
97539     } catch (std::exception& e) {
97540       {
97541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97542       };
97543     } catch (...) {
97544       {
97545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97546       };
97547     }
97548   }
97549   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97550
97551   return jresult;
97552 }
97553
97554
97555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97556   void * jresult ;
97557   std::string *arg1 = 0 ;
97558   Dali::ImageDimensions arg2 ;
97559   Dali::ImageDimensions *argp2 ;
97560   Dali::Devel::PixelBuffer result;
97561
97562   if (!jarg1) {
97563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97564     return 0;
97565   }
97566   std::string arg1_str(jarg1);
97567   arg1 = &arg1_str;
97568   argp2 = (Dali::ImageDimensions *)jarg2;
97569   if (!argp2) {
97570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97571     return 0;
97572   }
97573   arg2 = *argp2;
97574   {
97575     try {
97576       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97577     } catch (std::out_of_range& e) {
97578       {
97579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97580       };
97581     } catch (std::exception& e) {
97582       {
97583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97584       };
97585     } catch (...) {
97586       {
97587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97588       };
97589     }
97590   }
97591   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97592
97593   return jresult;
97594 }
97595
97596
97597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97598   void * jresult ;
97599   std::string *arg1 = 0 ;
97600   Dali::Devel::PixelBuffer result;
97601
97602   if (!jarg1) {
97603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97604     return 0;
97605   }
97606   std::string arg1_str(jarg1);
97607   arg1 = &arg1_str;
97608   {
97609     try {
97610       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97611     } catch (std::out_of_range& e) {
97612       {
97613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97614       };
97615     } catch (std::exception& e) {
97616       {
97617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97618       };
97619     } catch (...) {
97620       {
97621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97622       };
97623     }
97624   }
97625   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97626
97627   return jresult;
97628 }
97629
97630
97631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97632   void * jresult ;
97633   std::string *arg1 = 0 ;
97634   Dali::ImageDimensions arg2 ;
97635   Dali::FittingMode::Type arg3 ;
97636   Dali::SamplingMode::Type arg4 ;
97637   bool arg5 ;
97638   Dali::ImageDimensions *argp2 ;
97639   Dali::ImageDimensions result;
97640
97641   if (!jarg1) {
97642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97643     return 0;
97644   }
97645   std::string arg1_str(jarg1);
97646   arg1 = &arg1_str;
97647   argp2 = (Dali::ImageDimensions *)jarg2;
97648   if (!argp2) {
97649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97650     return 0;
97651   }
97652   arg2 = *argp2;
97653   arg3 = (Dali::FittingMode::Type)jarg3;
97654   arg4 = (Dali::SamplingMode::Type)jarg4;
97655   arg5 = jarg5 ? true : false;
97656   {
97657     try {
97658       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97659     } catch (std::out_of_range& e) {
97660       {
97661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97662       };
97663     } catch (std::exception& e) {
97664       {
97665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97666       };
97667     } catch (...) {
97668       {
97669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97670       };
97671     }
97672   }
97673   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97674
97675   return jresult;
97676 }
97677
97678
97679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97680   void * jresult ;
97681   std::string *arg1 = 0 ;
97682   Dali::ImageDimensions arg2 ;
97683   Dali::FittingMode::Type arg3 ;
97684   Dali::SamplingMode::Type arg4 ;
97685   Dali::ImageDimensions *argp2 ;
97686   Dali::ImageDimensions result;
97687
97688   if (!jarg1) {
97689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97690     return 0;
97691   }
97692   std::string arg1_str(jarg1);
97693   arg1 = &arg1_str;
97694   argp2 = (Dali::ImageDimensions *)jarg2;
97695   if (!argp2) {
97696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97697     return 0;
97698   }
97699   arg2 = *argp2;
97700   arg3 = (Dali::FittingMode::Type)jarg3;
97701   arg4 = (Dali::SamplingMode::Type)jarg4;
97702   {
97703     try {
97704       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97705     } catch (std::out_of_range& e) {
97706       {
97707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97708       };
97709     } catch (std::exception& e) {
97710       {
97711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97712       };
97713     } catch (...) {
97714       {
97715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97716       };
97717     }
97718   }
97719   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97720
97721   return jresult;
97722 }
97723
97724
97725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97726   void * jresult ;
97727   std::string *arg1 = 0 ;
97728   Dali::ImageDimensions arg2 ;
97729   Dali::FittingMode::Type arg3 ;
97730   Dali::ImageDimensions *argp2 ;
97731   Dali::ImageDimensions result;
97732
97733   if (!jarg1) {
97734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97735     return 0;
97736   }
97737   std::string arg1_str(jarg1);
97738   arg1 = &arg1_str;
97739   argp2 = (Dali::ImageDimensions *)jarg2;
97740   if (!argp2) {
97741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97742     return 0;
97743   }
97744   arg2 = *argp2;
97745   arg3 = (Dali::FittingMode::Type)jarg3;
97746   {
97747     try {
97748       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97749     } catch (std::out_of_range& e) {
97750       {
97751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97752       };
97753     } catch (std::exception& e) {
97754       {
97755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97756       };
97757     } catch (...) {
97758       {
97759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97760       };
97761     }
97762   }
97763   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97764
97765   return jresult;
97766 }
97767
97768
97769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97770   void * jresult ;
97771   std::string *arg1 = 0 ;
97772   Dali::ImageDimensions arg2 ;
97773   Dali::ImageDimensions *argp2 ;
97774   Dali::ImageDimensions result;
97775
97776   if (!jarg1) {
97777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97778     return 0;
97779   }
97780   std::string arg1_str(jarg1);
97781   arg1 = &arg1_str;
97782   argp2 = (Dali::ImageDimensions *)jarg2;
97783   if (!argp2) {
97784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97785     return 0;
97786   }
97787   arg2 = *argp2;
97788   {
97789     try {
97790       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97791     } catch (std::out_of_range& e) {
97792       {
97793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97794       };
97795     } catch (std::exception& e) {
97796       {
97797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97798       };
97799     } catch (...) {
97800       {
97801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97802       };
97803     }
97804   }
97805   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97806
97807   return jresult;
97808 }
97809
97810
97811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97812   void * jresult ;
97813   std::string *arg1 = 0 ;
97814   Dali::ImageDimensions result;
97815
97816   if (!jarg1) {
97817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97818     return 0;
97819   }
97820   std::string arg1_str(jarg1);
97821   arg1 = &arg1_str;
97822   {
97823     try {
97824       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97825     } catch (std::out_of_range& e) {
97826       {
97827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97828       };
97829     } catch (std::exception& e) {
97830       {
97831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97832       };
97833     } catch (...) {
97834       {
97835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97836       };
97837     }
97838   }
97839   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97840
97841   return jresult;
97842 }
97843
97844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97845   void * jresult ;
97846   std::string *arg1 = 0 ;
97847   Dali::ImageDimensions result;
97848
97849   if (!jarg1) {
97850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97851     return 0;
97852   }
97853   std::string arg1_str(jarg1);
97854   arg1 = &arg1_str;
97855   {
97856     try {
97857       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97858     } catch (std::out_of_range& e) {
97859       {
97860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97861       };
97862     } catch (std::exception& e) {
97863       {
97864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97865       };
97866     } catch (...) {
97867       {
97868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97869       };
97870     }
97871   }
97872   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97873
97874   return jresult;
97875 }
97876
97877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97878   void * jresult ;
97879   std::string *arg1 = 0 ;
97880   Dali::ImageDimensions arg2 ;
97881   Dali::FittingMode::Type arg3 ;
97882   Dali::SamplingMode::Type arg4 ;
97883   bool arg5 ;
97884   Dali::ImageDimensions *argp2 ;
97885   Dali::Devel::PixelBuffer result;
97886
97887   if (!jarg1) {
97888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97889     return 0;
97890   }
97891   std::string arg1_str(jarg1);
97892   arg1 = &arg1_str;
97893   argp2 = (Dali::ImageDimensions *)jarg2;
97894   if (!argp2) {
97895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97896     return 0;
97897   }
97898   arg2 = *argp2;
97899   arg3 = (Dali::FittingMode::Type)jarg3;
97900   arg4 = (Dali::SamplingMode::Type)jarg4;
97901   arg5 = jarg5 ? true : false;
97902   {
97903     try {
97904       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97905     } catch (std::out_of_range& e) {
97906       {
97907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97908       };
97909     } catch (std::exception& e) {
97910       {
97911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97912       };
97913     } catch (...) {
97914       {
97915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97916       };
97917     }
97918   }
97919   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97920
97921   return jresult;
97922 }
97923
97924
97925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97926   void * jresult ;
97927   std::string *arg1 = 0 ;
97928   Dali::ImageDimensions arg2 ;
97929   Dali::FittingMode::Type arg3 ;
97930   Dali::SamplingMode::Type arg4 ;
97931   Dali::ImageDimensions *argp2 ;
97932   Dali::Devel::PixelBuffer result;
97933
97934   if (!jarg1) {
97935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97936     return 0;
97937   }
97938   std::string arg1_str(jarg1);
97939   arg1 = &arg1_str;
97940   argp2 = (Dali::ImageDimensions *)jarg2;
97941   if (!argp2) {
97942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97943     return 0;
97944   }
97945   arg2 = *argp2;
97946   arg3 = (Dali::FittingMode::Type)jarg3;
97947   arg4 = (Dali::SamplingMode::Type)jarg4;
97948   {
97949     try {
97950       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97951     } catch (std::out_of_range& e) {
97952       {
97953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97954       };
97955     } catch (std::exception& e) {
97956       {
97957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97958       };
97959     } catch (...) {
97960       {
97961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97962       };
97963     }
97964   }
97965   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97966
97967   return jresult;
97968 }
97969
97970
97971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97972   void * jresult ;
97973   std::string *arg1 = 0 ;
97974   Dali::ImageDimensions arg2 ;
97975   Dali::FittingMode::Type arg3 ;
97976   Dali::ImageDimensions *argp2 ;
97977   Dali::Devel::PixelBuffer result;
97978
97979   if (!jarg1) {
97980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97981     return 0;
97982   }
97983   std::string arg1_str(jarg1);
97984   arg1 = &arg1_str;
97985   argp2 = (Dali::ImageDimensions *)jarg2;
97986   if (!argp2) {
97987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97988     return 0;
97989   }
97990   arg2 = *argp2;
97991   arg3 = (Dali::FittingMode::Type)jarg3;
97992   {
97993     try {
97994       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97995     } catch (std::out_of_range& e) {
97996       {
97997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97998       };
97999     } catch (std::exception& e) {
98000       {
98001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98002       };
98003     } catch (...) {
98004       {
98005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98006       };
98007     }
98008   }
98009   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98010
98011   return jresult;
98012 }
98013
98014
98015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
98016   void * jresult ;
98017   std::string *arg1 = 0 ;
98018   Dali::ImageDimensions arg2 ;
98019   Dali::ImageDimensions *argp2 ;
98020   Dali::Devel::PixelBuffer result;
98021
98022   if (!jarg1) {
98023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98024     return 0;
98025   }
98026   std::string arg1_str(jarg1);
98027   arg1 = &arg1_str;
98028   argp2 = (Dali::ImageDimensions *)jarg2;
98029   if (!argp2) {
98030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98031     return 0;
98032   }
98033   arg2 = *argp2;
98034   {
98035     try {
98036       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
98037     } catch (std::out_of_range& e) {
98038       {
98039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98040       };
98041     } catch (std::exception& e) {
98042       {
98043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98044       };
98045     } catch (...) {
98046       {
98047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98048       };
98049     }
98050   }
98051   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98052
98053   return jresult;
98054 }
98055
98056
98057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
98058   void * jresult ;
98059   std::string *arg1 = 0 ;
98060   Dali::Devel::PixelBuffer result;
98061
98062   if (!jarg1) {
98063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98064     return 0;
98065   }
98066   std::string arg1_str(jarg1);
98067   arg1 = &arg1_str;
98068   {
98069     try {
98070       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98071     } catch (std::out_of_range& e) {
98072       {
98073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98074       };
98075     } catch (std::exception& e) {
98076       {
98077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98078       };
98079     } catch (...) {
98080       {
98081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98082       };
98083     }
98084   }
98085   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98086
98087   return jresult;
98088 }
98089
98090
98091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98092   void * jresult ;
98093   Dali::Toolkit::WebView result;
98094
98095   {
98096     try {
98097       result = Dali::Toolkit::WebView::New();
98098     } catch (std::out_of_range& e) {
98099       {
98100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98101       };
98102     } catch (std::exception& e) {
98103       {
98104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98105       };
98106     } catch (Dali::DaliException e) {
98107       {
98108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98109       };
98110     } catch (...) {
98111       {
98112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98113       };
98114     }
98115   }
98116   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98117   return jresult;
98118 }
98119
98120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98121   void * jresult ;
98122   Dali::Toolkit::WebView result;
98123
98124   std::string *arg1;
98125   std::string *arg2;
98126
98127   if (!jarg1) {
98128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98129     return 0;
98130   }
98131   if (!jarg2) {
98132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98133     return 0;
98134   }
98135
98136   std::string jarg1_str = std::string(jarg1);
98137   std::string jarg2_str = std::string(jarg2);
98138
98139   arg1 = &jarg1_str;
98140   arg2 = &jarg2_str;
98141
98142   {
98143     try {
98144       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98145     } catch (std::out_of_range& e) {
98146       {
98147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98148       };
98149     } catch (std::exception& e) {
98150       {
98151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98152       };
98153     } catch (Dali::DaliException e) {
98154       {
98155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98156       };
98157     } catch (...) {
98158       {
98159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98160       };
98161     }
98162   }
98163   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98164   return jresult;
98165 }
98166
98167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98168   void * jresult ;
98169   Dali::Toolkit::WebView *arg1 = 0 ;
98170   Dali::Toolkit::WebView *result = 0 ;
98171
98172   arg1 = (Dali::Toolkit::WebView *)jarg1;
98173   if (!arg1) {
98174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98175     return 0;
98176   }
98177   {
98178     try {
98179       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98180     } catch (std::out_of_range& e) {
98181       {
98182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98183       };
98184     } catch (std::exception& e) {
98185       {
98186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98187       };
98188     } catch (Dali::DaliException e) {
98189       {
98190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98191       };
98192     } catch (...) {
98193       {
98194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98195       };
98196     }
98197   }
98198   jresult = (void *)result;
98199   return jresult;
98200 }
98201
98202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98203   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98204   arg1 = (Dali::Toolkit::WebView *)jarg1;
98205   {
98206     try {
98207       delete arg1;
98208     } catch (std::out_of_range& e) {
98209       {
98210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98211       };
98212     } catch (std::exception& e) {
98213       {
98214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98215       };
98216     } catch (Dali::DaliException e) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98219       };
98220     } catch (...) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98223       };
98224     }
98225   }
98226 }
98227
98228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98229   void * jresult ;
98230   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98231   Dali::Toolkit::WebView *arg2 = 0 ;
98232   Dali::Toolkit::WebView *result = 0 ;
98233
98234   arg1 = (Dali::Toolkit::WebView *)jarg1;
98235   arg2 = (Dali::Toolkit::WebView *)jarg2;
98236   if (!arg2) {
98237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98238     return 0;
98239   }
98240   {
98241     try {
98242       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98243     } catch (std::out_of_range& e) {
98244       {
98245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98246       };
98247     } catch (std::exception& e) {
98248       {
98249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98250       };
98251     } catch (Dali::DaliException e) {
98252       {
98253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98254       };
98255     } catch (...) {
98256       {
98257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98258       };
98259     }
98260   }
98261   jresult = (void *)result;
98262   return jresult;
98263 }
98264
98265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98266   void * jresult ;
98267   Dali::BaseHandle arg1 ;
98268   Dali::BaseHandle *argp1 ;
98269   Dali::Toolkit::WebView result;
98270
98271   argp1 = (Dali::BaseHandle *)jarg1;
98272   if (!argp1) {
98273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98274     return 0;
98275   }
98276   arg1 = *argp1;
98277   {
98278     try {
98279       result = Dali::Toolkit::WebView::DownCast(arg1);
98280     } catch (std::out_of_range& e) {
98281       {
98282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98283       };
98284     } catch (std::exception& e) {
98285       {
98286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98287       };
98288     } catch (Dali::DaliException e) {
98289       {
98290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98291       };
98292     } catch (...) {
98293       {
98294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98295       };
98296     }
98297   }
98298   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98299   return jresult;
98300 }
98301
98302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98303   return (int) Dali::Toolkit::WebView::Property::URL;
98304 }
98305
98306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98307   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98308 }
98309
98310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98311   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98312 }
98313
98314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98315   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98316 }
98317
98318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98319   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98320 }
98321
98322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98323   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98324 }
98325
98326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98327   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98328 }
98329
98330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98331   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98332 }
98333
98334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98335   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98336   std::string *arg2;
98337
98338   arg1 = (Dali::Toolkit::WebView *)jarg1;
98339
98340   if (!jarg2) {
98341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98342     return;
98343   }
98344
98345   std::string jarg2str = std::string(jarg2);
98346   arg2 = &jarg2str;
98347   {
98348     try {
98349       (arg1)->LoadUrl((std::string const &)*arg2);
98350     } catch (std::out_of_range& e) {
98351       {
98352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98353       };
98354     } catch (std::exception& e) {
98355       {
98356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98357       };
98358     } catch (Dali::DaliException e) {
98359       {
98360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98361       };
98362     } catch (...) {
98363       {
98364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98365       };
98366     }
98367   }
98368 }
98369
98370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98371   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98372   std::string *arg2;
98373
98374   arg1 = (Dali::Toolkit::WebView *)jarg1;
98375   if (!jarg2) {
98376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98377     return;
98378   }
98379   std::string jarg2str = std::string(jarg2);
98380   arg2 = &jarg2str;
98381   {
98382     try {
98383       (arg1)->LoadHTMLString((std::string const &)*arg2);
98384     } catch (std::out_of_range& e) {
98385       {
98386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98387       };
98388     } catch (std::exception& e) {
98389       {
98390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98391       };
98392     } catch (Dali::DaliException e) {
98393       {
98394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98395       };
98396     } catch (...) {
98397       {
98398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98399       };
98400     }
98401   }
98402 }
98403
98404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98405   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98406
98407   arg1 = (Dali::Toolkit::WebView *)jarg1;
98408   {
98409     try {
98410       (arg1)->Reload();
98411     } catch (std::out_of_range& e) {
98412       {
98413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98414       };
98415     } catch (std::exception& e) {
98416       {
98417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98418       };
98419     } catch (Dali::DaliException e) {
98420       {
98421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98422       };
98423     } catch (...) {
98424       {
98425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98426       };
98427     }
98428   }
98429 }
98430
98431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98432   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98433
98434   arg1 = (Dali::Toolkit::WebView *)jarg1;
98435   {
98436     try {
98437       (arg1)->StopLoading();
98438     } catch (std::out_of_range& e) {
98439       {
98440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98441       };
98442     } catch (std::exception& e) {
98443       {
98444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98445       };
98446     } catch (Dali::DaliException e) {
98447       {
98448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98449       };
98450     } catch (...) {
98451       {
98452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98453       };
98454     }
98455   }
98456 }
98457
98458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98459   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98460
98461   arg1 = (Dali::Toolkit::WebView *)jarg1;
98462   {
98463     try {
98464       (arg1)->Suspend();
98465     } catch (std::out_of_range& e) {
98466       {
98467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98468       };
98469     } catch (std::exception& e) {
98470       {
98471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98472       };
98473     } catch (Dali::DaliException e) {
98474       {
98475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98476       };
98477     } catch (...) {
98478       {
98479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98480       };
98481     }
98482   }
98483 }
98484
98485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98486   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98487
98488   arg1 = (Dali::Toolkit::WebView *)jarg1;
98489   {
98490     try {
98491       (arg1)->Resume();
98492     } catch (std::out_of_range& e) {
98493       {
98494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98495       };
98496     } catch (std::exception& e) {
98497       {
98498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98499       };
98500     } catch (Dali::DaliException e) {
98501       {
98502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98503       };
98504     } catch (...) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98507       };
98508     }
98509   }
98510 }
98511
98512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98513   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98514
98515   arg1 = (Dali::Toolkit::WebView *)jarg1;
98516   {
98517     try {
98518       (arg1)->GoBack();
98519     } catch (std::out_of_range& e) {
98520       {
98521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98522       };
98523     } catch (std::exception& e) {
98524       {
98525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98526       };
98527     } catch (Dali::DaliException e) {
98528       {
98529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98530       };
98531     } catch (...) {
98532       {
98533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98534       };
98535     }
98536   }
98537 }
98538
98539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98540   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98541
98542   arg1 = (Dali::Toolkit::WebView *)jarg1;
98543   {
98544     try {
98545       (arg1)->GoForward();
98546     } catch (std::out_of_range& e) {
98547       {
98548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98549       };
98550     } catch (std::exception& e) {
98551       {
98552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98553       };
98554     } catch (Dali::DaliException e) {
98555       {
98556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98557       };
98558     } catch (...) {
98559       {
98560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98561       };
98562     }
98563   }
98564 }
98565
98566 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98567   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98568   bool ret;
98569
98570   arg1 = (Dali::Toolkit::WebView *)jarg1;
98571   {
98572     try {
98573       ret = (arg1)->CanGoBack();
98574     } catch (std::out_of_range& e) {
98575       {
98576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98577       };
98578     } catch (std::exception& e) {
98579       {
98580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98581       };
98582     } catch (Dali::DaliException e) {
98583       {
98584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98585       };
98586     } catch (...) {
98587       {
98588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98589       };
98590     }
98591   }
98592   return ret;
98593 }
98594
98595 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98596   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98597   bool ret;
98598
98599   arg1 = (Dali::Toolkit::WebView *)jarg1;
98600   {
98601     try {
98602       ret = (arg1)->CanGoForward();
98603     } catch (std::out_of_range& e) {
98604       {
98605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98606       };
98607     } catch (std::exception& e) {
98608       {
98609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98610       };
98611     } catch (Dali::DaliException e) {
98612       {
98613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98614       };
98615     } catch (...) {
98616       {
98617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98618       };
98619     }
98620   }
98621   return ret;
98622 }
98623
98624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98625   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98626   std::string *arg2;
98627
98628   arg1 = (Dali::Toolkit::WebView *)jarg1;
98629   if (!jarg2) {
98630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98631     return;
98632   }
98633   std::string jarg2_str = std::string(jarg2);
98634   arg2 = &jarg2_str;
98635
98636   {
98637     try {
98638       if (jarg3) {
98639         void (*handler)(char*) = (void (*)(char*)) jarg3;
98640         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98641           handler(SWIG_csharp_string_callback(result.c_str()));
98642         });
98643       } else {
98644         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98645       }
98646     } catch (std::out_of_range& e) {
98647       {
98648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98649       };
98650     } catch (std::exception& e) {
98651       {
98652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98653       };
98654     } catch (Dali::DaliException e) {
98655       {
98656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98657       };
98658     } catch (...) {
98659       {
98660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98661       };
98662     }
98663   }
98664 }
98665
98666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98667 {
98668   if (!jarg2) {
98669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98670     return;
98671   }
98672
98673   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98674   std::string exposedObjectName = jarg2;
98675   void (*handler)(char*) = (void (*)(char*)) jarg3;
98676
98677   {
98678     try {
98679       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98680         handler(SWIG_csharp_string_callback(message.c_str()));
98681       });
98682     } catch (std::out_of_range& e) {
98683       {
98684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98685       };
98686     } catch (std::exception& e) {
98687       {
98688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98689       };
98690     } catch (Dali::DaliException e) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98693       };
98694     } catch (...) {
98695       {
98696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98697       };
98698     }
98699   }
98700 }
98701
98702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98703   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98704
98705   arg1 = (Dali::Toolkit::WebView *)jarg1;
98706   {
98707     try {
98708       (arg1)->ClearHistory();
98709     } catch (std::out_of_range& e) {
98710       {
98711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98712       };
98713     } catch (std::exception& e) {
98714       {
98715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98716       };
98717     } catch (Dali::DaliException e) {
98718       {
98719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98720       };
98721     } catch (...) {
98722       {
98723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98724       };
98725     }
98726   }
98727 }
98728
98729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98730   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98731
98732   arg1 = (Dali::Toolkit::WebView *)jarg1;
98733   {
98734     try {
98735       (arg1)->ClearCache();
98736     } catch (std::out_of_range& e) {
98737       {
98738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98739       };
98740     } catch (std::exception& e) {
98741       {
98742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98743       };
98744     } catch (Dali::DaliException e) {
98745       {
98746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98747       };
98748     } catch (...) {
98749       {
98750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98751       };
98752     }
98753   }
98754 }
98755
98756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98757   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98758
98759   arg1 = (Dali::Toolkit::WebView *)jarg1;
98760   {
98761     try {
98762       (arg1)->ClearCookies();
98763     } catch (std::out_of_range& e) {
98764       {
98765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98766       };
98767     } catch (std::exception& e) {
98768       {
98769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98770       };
98771     } catch (Dali::DaliException e) {
98772       {
98773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98774       };
98775     } catch (...) {
98776       {
98777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98778       };
98779     }
98780   }
98781 }
98782
98783 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98784     return (Dali::Toolkit::Control *)jarg1;
98785 }
98786
98787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98788   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98789   SignalConverter::WebViewPageLoadSignal* result = NULL;
98790   {
98791     try {
98792       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98793     } catch (std::out_of_range& e) {
98794       {
98795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98796       };
98797     } catch (std::exception& e) {
98798       {
98799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98800       };
98801     } catch (Dali::DaliException e) {
98802       {
98803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98804       };
98805     } catch (...) {
98806       {
98807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98808       };
98809     }
98810   }
98811   return (void*) result;
98812 }
98813
98814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98815   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98816   SignalConverter::WebViewPageLoadSignal* result = NULL;
98817   {
98818     try {
98819       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98820     } catch (std::out_of_range& e) {
98821       {
98822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98823       };
98824     } catch (std::exception& e) {
98825       {
98826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98827       };
98828     } catch (Dali::DaliException e) {
98829       {
98830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98831       };
98832     } catch (...) {
98833       {
98834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98835       };
98836     }
98837   }
98838   return (void*) result;
98839 }
98840
98841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98842 {
98843   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98844   {
98845     try {
98846       delete object;
98847     } catch (std::out_of_range& e) {
98848       {
98849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98850       };
98851     } catch (std::exception& e) {
98852       {
98853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98854       };
98855     } catch (Dali::DaliException e) {
98856       {
98857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98858       };
98859     } catch (...) {
98860       {
98861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98862       };
98863     }
98864   }
98865 }
98866
98867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98868 {
98869   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98870   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98871   {
98872     try {
98873       proxy->Connect(callback);
98874     } catch (std::out_of_range& e) {
98875       {
98876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98877       };
98878     } catch (std::exception& e) {
98879       {
98880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98881       };
98882     } catch (Dali::DaliException e) {
98883       {
98884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98885       };
98886     } catch (...) {
98887       {
98888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98889       };
98890     }
98891   }
98892 }
98893
98894
98895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98896   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98897   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98898   {
98899     try {
98900       proxy->Disconnect(callback);
98901     } catch (std::out_of_range& e) {
98902       {
98903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98904       };
98905     } catch (std::exception& e) {
98906       {
98907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98908       };
98909     } catch (Dali::DaliException e) {
98910       {
98911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98912       };
98913     } catch (...) {
98914       {
98915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98916       };
98917     }
98918   }
98919 }
98920
98921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98922   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98923   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98924   {
98925     try {
98926       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98927     } catch (std::out_of_range& e) {
98928       {
98929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98930       };
98931     } catch (std::exception& e) {
98932       {
98933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98934       };
98935     } catch (Dali::DaliException e) {
98936       {
98937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98938       };
98939     } catch (...) {
98940       {
98941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98942       };
98943     }
98944   }
98945   return (void*) result;
98946 }
98947
98948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98949 {
98950   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98951   {
98952     try {
98953       delete object;
98954     } catch (std::out_of_range& e) {
98955       {
98956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98957       };
98958     } catch (std::exception& e) {
98959       {
98960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98961       };
98962     } catch (Dali::DaliException e) {
98963       {
98964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98965       };
98966     } catch (...) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98969       };
98970     }
98971   }
98972 }
98973
98974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98975 {
98976   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98977   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98978   {
98979     try {
98980       proxy->Connect(callback);
98981     } catch (std::out_of_range& e) {
98982       {
98983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98984       };
98985     } catch (std::exception& e) {
98986       {
98987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98988       };
98989     } catch (Dali::DaliException e) {
98990       {
98991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98992       };
98993     } catch (...) {
98994       {
98995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98996       };
98997     }
98998   }
98999 }
99000
99001
99002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
99003   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99004   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99005   {
99006     try {
99007       proxy->Disconnect(callback);
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 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
99029   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
99030   char * jresult = SWIG_csharp_string_callback((const char *)result);
99031   return jresult;
99032 }
99033
99034 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
99035   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
99036   return result;
99037 }
99038
99039
99040 struct NativeImageSourcePtrHandle
99041 {
99042   NativeImageSourcePtr Ptr;
99043 };
99044
99045 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
99046 {
99047   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99048   return (NativeImageInterface*)(arg1);
99049 }
99050
99051 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
99052 {
99053   void* jresult;
99054   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
99055   {
99056     try {
99057       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
99058     }
99059     catch (std::out_of_range & e) {
99060       {
99061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99062       };
99063     }
99064     catch (std::exception & e) {
99065       {
99066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99067       };
99068     }
99069     catch (Dali::DaliException e) {
99070       {
99071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99072       };
99073     }
99074     catch (...) {
99075       {
99076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99077       };
99078     }
99079   }
99080   jresult = (void *)handle;
99081   return jresult;
99082 }
99083
99084 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99085 {
99086   void* jresult;
99087   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99088   jresult = (void*)( handle->Ptr.Get() );
99089   return jresult;
99090 }
99091
99092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99093   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99094   {
99095     try {
99096       delete arg1;
99097     }
99098     catch (std::out_of_range & e) {
99099       {
99100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99101       };
99102     }
99103     catch (std::exception & e) {
99104       {
99105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99106       };
99107     }
99108     catch (Dali::DaliException e) {
99109       {
99110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99111       };
99112     }
99113     catch (...) {
99114       {
99115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99116       };
99117     }
99118   }
99119 }
99120
99121 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99122 {
99123   void* jresult;
99124   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99125   uint16_t* arg2 = (uint16_t*)(jarg2);
99126   uint16_t* arg3 = (uint16_t*)(jarg3);
99127   uint16_t* arg4 = (uint16_t*)(jarg4);
99128   {
99129     try {
99130       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99131     }
99132     catch (std::out_of_range & e) {
99133       {
99134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99135       };
99136     }
99137     catch (std::exception & e) {
99138       {
99139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99140       };
99141     }
99142     catch (Dali::DaliException e) {
99143       {
99144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99145       };
99146     }
99147     catch (...) {
99148       {
99149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99150       };
99151     }
99152   }
99153   return jresult;
99154 }
99155
99156 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99157 {
99158   bool jresult;
99159   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99160
99161   {
99162     try {
99163       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99164     }
99165     catch (std::out_of_range & e) {
99166       {
99167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99168       };
99169     }
99170     catch (std::exception & e) {
99171       {
99172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99173       };
99174     }
99175     catch (Dali::DaliException e) {
99176       {
99177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99178       };
99179     }
99180     catch (...) {
99181       {
99182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99183       };
99184     }
99185   }
99186   return jresult;
99187 }
99188
99189
99190 #ifdef __cplusplus
99191 }
99192 #endif